weatherdb 1.1.0__py3-none-any.whl

weatherdb/config/config_default.ini

@@ -0,0 +1,162 @@
+[database]
+; These are the main database settings
+; The database is created with the cli command create-db-schema or the weatherdb.Broker().create_db_schema() method
+; you can define multiple database connections by adding a new section like [database.connection_name], where you can define your connection name
+; The connection setting defines which connection is used if not specified
+connection = main
+
+[database:main]
+; setup a database connection
+; The password should not be stored in the config file, as it is a security risk.
+; the module will ask for the password on first execution and store it in the keyring.
+HOST = localhost
+PORT = 5432
+DATABASE = weatherdb
+USER = weatherdb_user
+
+[database:owner]
+; You can setup multiple database connections
+HOST = localhost
+PORT = 5432
+DATABASE = weatherdb
+USER = weatherdb_owner
+
+[logging]
+; The logging settings
+; Should the log be written to a file or to the console
+; Possible values: file, console
+HANDLERS =
+
+; The log level
+; Possible values: DEBUG, INFO, WARNING, ERROR, CRITICAL
+LEVEL = DEBUG
+
+; The log directory
+; The path can contain the module path as basis with ${main:module_path} or the complete path.
+; if the log should be written to the console, this setting is ignored
+DIRECTORY = ${main:module_path}/logs
+
+; The log file template
+; The log file will be named with the template and rotated daily with the date appended
+; The template can contain the computer host name with {host} and the current user name with {user}
+FILE = weatherDB_{host}_{user}.log
+
+; Should the older rotated log files be compressed or not?
+; Possible values: True, False
+; The default is True
+COMPRESSION = True
+
+; The log file format
+; The format can contain the following variables:
+; {asctime} - the time of the log entry
+; {name} - the name of the logger
+; {levelname} - the log level
+; {message} - the log message
+FORMAT = %(asctime)s - %(name)s - %(levelname)s - %(message)s
+
+[data]
+; The WeatherDB module needs several data files to work properly.
+; those files are only used by the main managing module, not by the users.
+
+; The data files like multi annual and dems rasters are normaly stored in the data directory.
+; The path can contain the module path as basis with ${main:module_path} or the complete path.
+; if they are stored somewhere else set the path here
+BASE_DIR = ${main:module_path}/data
+
+[data:rasters]
+; Digital elevation models (DEM)
+; The paths can contain the module path as basis with ${main:module_path} or the DATA.BASE_DIR with ${data:BASE_DIR} or the complete path.
+; The module needs at least one DEM to calculate the horizon shadowing angle.
+; as finer DEM are sometimes not covering the whole area of germany+40km, that is needed, you can add additional DEMs, that gets used if the first one
+; the DEMs are used in the order of appearance in the list
+DEMS = ${data:BASE_DIR}/DEM/DEM25.tif,
+       ${data:BASE_DIR}/DEM/DEM80.tif
+
+; Regionalisation Rasters
+; the module works with regionalised multi-annual rasters from the DWD
+; the module needs at least the HYRAS and DWD raster, as this is the basis for the regionalisation of the station data
+; The rasters should be in a cartesian coordinate system with meter as unit to be able to calculate distances (e.g. EPSG:3035)
+
+[data:rasters:hyras]
+; multi annual HYRAS raster
+; The original data can be found on: https://opendata.dwd.de/climate_environment/CDC/grids_germany/multi_annual/hyras_de/precipitation/
+; to get better results, we refined the 1km rasters to 25m raster, based on a DEM25. (this file is not providen, but can be asked for)
+FILE = ${data:BASE_DIR}/regionalisation/HYRAS_ma_1991_2020_DGM25.tif
+
+; This raster file should have at least 3 raster bands for summer, winter and yearly means.
+; Give the rasters names or band numbers
+BAND_P_WIHY = n_hyras_wihj
+BAND_P_SUHY = n_hyras_sohj
+BAND_P_YEAR = n_hyras_year
+
+; The EPSG code of the rasters if not defined in the raster file itself
+SRID = 3035
+
+; factors to apply to raster value to get to mm or °C
+; the rasters should be in integer format, as the factors are applied to the raster values to get decimal values
+FACTOR_P_WIHY = 1
+FACTOR_P_SUHY = 1
+FACTOR_P_YEAR = 1
+
+[data:rasters:dwd]
+; multi annual DWD raster
+FILE = ${data:BASE_DIR}/regionalisation/DWD-grid_ma_1991_2020_DGM25.tif
+BAND_P_WIHY = n_wihj
+BAND_P_SUHY = n_sohj
+BAND_P_YEAR = n_year
+BAND_T_YEAR = t_year
+BAND_ET_YEAR = et_year
+
+; The EPSG code of the rasters if not defined in the raster file itself
+SRID = 3035
+
+; factors to apply to raster value to get to mm or °C
+; the rasters should be in integer format, as the factors are applied to the raster values to get decimal values
+FACTOR_P_WIHY = 1
+FACTOR_P_SUHY = 1
+FACTOR_P_YEAR = 1
+FACTOR_T_YEAR = 0.1
+FACTOR_ET_YEAR = 1
+
+[weatherdb]
+; The WeatherDB module settings to setup different parts of the module
+
+; The radius in meters to use for the horizon shadowing calculation
+; The default is 75km, this value got defined because the maximum possible height is around 4000m for germany
+; --> horizon angle = arctan(4/75) ~ 3°, this is the lowest category in the richter class table
+HORIZON_RADIUS = 75000
+
+; The projected coordinate reference system (CRS) to use for the calculation of the distance during the horizon shadowing calculation
+; This can be different than the DEM CRS, but has to be a projected CRS with meter as unit
+; The value should be an EPSG code, e.g. 25832 for UTM zone 32N
+; The default is UTM zone 32N (EPSG:25832)
+HORIZON_CRS = 25832
+
+; The projected coordinate reference system (CRS) to use for the calculation of the distance during raster sampling
+; This can be different than the DEM CRS, but has to be a projected CRS with meter as unit
+; The value should be an EPSG code, e.g. 25832 for UTM zone 32N
+; The default is the same as the HORISON_CRS
+RASTER_BUFFER_CRS = ${weatherdb:HORIZON_CRS}
+
+; The minimum date to download data from the DWD
+; The earlier you go the less data is available and the further away the stations have to be to fill the timeseries
+; The default is 1999-01-01
+MIN_DATE = 1999-01-01
+
+
+[weatherdb:max_fillup_distance]
+; The maximum distance in meters to use for the filling of the station data
+; For each parameter (P, T, ET) the module uses a different distance
+; Precipitation (P)
+P = 110000
+; Temperature (T)
+T = 150000
+; Evapotranspiration (ET)
+ET = 150000
+
+; for developpers:
+; ----------------
+;
+; [alembic]
+; The database connection used by the alembic scripts
+; connection = main

weatherdb/db/__init__.py

@@ -0,0 +1,3 @@
+from .connections import db_engine
+from . import models
+from . import views

weatherdb/db/connections.py

@@ -0,0 +1,374 @@
+# libraries
+import sqlalchemy
+from sqlalchemy import text as sqltxt
+from sqlalchemy import URL
+import functools
+
+from ..config import config
+
+# DB connection
+###############
+class DBEngine:
+    def __init__(self):
+        self._reset_engine()
+
+        # add the listeners for configuration changes
+        self._config_listener_connection = (
+            "database",
+            "connection",
+            self._connection_update)
+        self._config_listener_subsection = (
+            f"database:{config.get('database', 'connection')}",
+            None,
+            self._reset_engine)
+        config.add_listener(*self._config_listener_connection)
+        config.add_listener(*self._config_listener_subsection)
+
+    def __del__(self):
+        config.remove_listener(*self._config_listener_connection)
+        config.remove_listener(*self._config_listener_subsection)
+
+    def _connection_update(self):
+        """Listener if another database subsection is selected."""
+        # first remove the old section listener
+        config.remove_listener(*self._config_listener_subsection)
+
+        # add the new section listener
+        self._config_listener_subsection = (
+            f"database:{config.get('database', 'connection')}",
+            None,
+            self._reset_engine)
+        config.add_listener(*self._config_listener_subsection)
+
+        # create a new engine
+        self.create_engine()
+
+    # Engine and Session
+    # ##################
+    def _reset_engine(self):
+        """Reset the engine to None to force a recreation on next usage."""
+        self._engine = None
+        self._session = None
+        self._is_superuser = None
+        self._select_privilege = None
+        self._create_privilege = None
+        self._update_privilege = None
+        self._insert_privilege = None
+        self._delete_privilege = None
+        self._priviledge_to_recheck = set()
+
+    def connect(self, *args, **kwargs):
+        return self.get_engine().connect(*args, **kwargs)
+
+    def get_engine(self):
+        """Get the sqlalchemy database engine.
+
+        Returns the last created engine if possible or creates a new one.
+
+        Returns
+        -------
+        sqlalchemy.engine.base.Engine
+            _description_
+        """
+        if self._engine is None:
+            self.create_engine()
+
+        return self._engine
+
+    def create_engine(self):
+        # create the engine
+        con_key = config.get("database", "connection")
+        con_sect_key = f"database:{con_key}"
+        con_section = config[con_sect_key]
+        user, pwd = config.get_db_credentials()
+        self._engine = sqlalchemy.create_engine(
+            URL.create(
+                drivername="postgresql+psycopg2",
+                username=user,
+                password=pwd,
+                host=con_section["HOST"],
+                database=con_section["DATABASE"],
+                port=con_section["PORT"]),
+            connect_args={
+                "options": "-c timezone=utc",
+                'connect_timeout': 10})
+        self._check_is_superuser()
+
+        return self._engine
+
+    @property
+    def engine(self):
+        return self.get_engine()
+
+    @engine.setter
+    def engine(self, value):
+        raise PermissionError("You are not allowed to change the engine of the database connection.\nPlease change the configuration to change the database connection.")
+
+    def create_session(self):
+        """Create a new session from the engine.
+
+        Returns
+        -------
+        sqlalchemy.orm.session.Session
+            _description_
+        """
+        self._session = sqlalchemy.orm.sessionmaker(bind=self.get_engine())
+        return self._session
+
+    def get_session(self):
+        """Get a session from the engine.
+
+        Returns
+        -------
+        sqlalchemy.orm.session.Session
+            _description_
+        """
+        if self._session is None:
+            return self.create_session()
+        else:
+            return self._session
+
+    @property
+    def session(self):
+        return self.get_session()
+
+    @session.setter
+    def session(self, value):
+        raise PermissionError("You are not allowed to change the session of the database connection.\nPlease change the configuration to change the database connection.")
+
+    def reload_config(self):
+        """Reload the configuration and create a new engine.
+        """
+        self.create_engine()
+
+    # Privilege checks
+    ##################
+    def _check_is_superuser(self):
+        with self.connect() as con:
+            self._is_superuser = con.execute(sqltxt(
+                "SELECT usesuper FROM pg_user WHERE usename = current_user;"
+            )).first()[0]
+        return self._is_superuser
+
+    @property
+    def is_superuser(self):
+        if self._is_superuser is None:
+            self._check_is_superuser()
+        return self._is_superuser
+
+    @is_superuser.setter
+    def is_superuser(self, value):
+        raise PermissionError("You are not allowed to change the superuser status of the database connection, as this is due to PostGreSQL database privileges of your database user.")
+
+    def _check_privilege(self, privilege):
+        if self._is_superuser:
+            return True
+        else:
+            with self.connect() as con:
+                if privilege == "CREATE":
+                    return con.execute(sqltxt(
+                        f"SELECT pg_catalog.has_schema_privilege('public', '{privilege}');"
+                    )).first()[0]
+                res = con.execute(sqltxt(
+                    f"""SELECT bool_and(pg_catalog.has_table_privilege(table_name, '{privilege}'))
+                       FROM information_schema.TABLES
+                       WHERE table_schema=CURRENT_SCHEMA AND table_type='BASE TABLE';"""
+                )).first()[0]
+                if res is None:
+                    if privilege in self._priviledge_to_recheck:
+                        self.log.debug(f"Privilege {privilege} not found, probably because database isn't initiated. Setting as True.")
+                    else:
+                        self._priviledge_to_recheck.add(privilege)
+                    return True
+                else:
+                    if privilege in self._priviledge_to_recheck:
+                        self._priviledge_to_recheck.remove(privilege)
+                    return res
+
+    def _check_select_privilege(self):
+        """Check on the database if the user has the SELECT privilege."""
+        self._select_privilege = self._check_privilege("SELECT")
+        return self._select_privilege
+
+    def _check_update_privilege(self):
+        """Check on the database if the user has the UPDATE privilege."""
+        self._update_privilege = self._check_privilege("UPDATE")
+        return self._update_privilege
+
+    def _check_insert_privilege(self):
+        """Check on the database if the user has the INSERT privilege."""
+        self._insert_privilege = self._check_privilege("INSERT")
+        return self._insert_privilege
+
+    def _check_create_privilege(self):
+        """Check on the database if the user has the CREATE privilege."""
+        self._create_privilege = self._check_privilege("CREATE")
+        return self._create_privilege
+
+    def _check_delete_privilege(self):
+        """Check on the database if the user has the DELETE privilege."""
+        self._delete_privilege = self._check_privilege("DELETE")
+        return self._delete_privilege
+
+    @property
+    def select_privilege(self):
+        """Does the user have the PostGreSQL SELECT privilege on the database?"""
+        if self._select_privilege is None or "SELECT" in self._priviledge_to_recheck:
+            self._check_select_privilege()
+        return self._select_privilege
+
+    @property
+    def update_privilege(self):
+        """Does the user have the PostGreSQL UPDATE privilege on the database?"""
+        if self._update_privilege is None or "UPDATE" in self._priviledge_to_recheck:
+            self._check_update_privilege()
+        return self._update_privilege
+
+    @property
+    def insert_privilege(self):
+        """Does the user have the PostGreSQL INSERT privilege on the database?"""
+        if self._insert_privilege is None or "INSERT" in self._priviledge_to_recheck:
+            self._check_insert_privilege()
+        return self._insert_privilege
+
+    @property
+    def upsert_privilege(self):
+        """Does the user have the PostGreSQL INSERT and UPDATE privilege on the database?"""
+        return self.insert_privilege and self.update_privilege
+
+    @property
+    def create_privilege(self):
+        """Does the user have the PostGreSQL CREATE privilege on the database?"""
+        if self._create_privilege is None or "CREATE" in self._priviledge_to_recheck:
+            self._check_create_privilege()
+        return self._create_privilege
+
+    @property
+    def delete_privilege(self):
+        """Does the user have the PostGreSQL DELETE privilege on the database?"""
+        if self._delete_privilege is None or "DELETE" in self._priviledge_to_recheck:
+            self._check_delete_privilege()
+        return self._delete_privilege
+
+    @property
+    def all_privileges(self):
+        """Does the user have all (SELECT, UPDATE, INSERT, DELETE, CREATE) PostGreSQL privileges on the database?"""
+        return self.select_privilege and \
+            self.update_privilege and \
+            self.insert_privilege and \
+            self.create_privilege and \
+            self.delete_privilege
+
+    def _privilege_setters(self, property_name):
+        raise PermissionError(f"You are not allowed to change the value of {property_name} as this is due to PostGreSQL database privileges of your user.")
+
+    @select_privilege.setter
+    def select_privilege(self, value):
+        self._privilege_setters("select_privilege")
+
+    @update_privilege.setter
+    def update_privilege(self, value):
+        self._privilege_setters("update_privilege")
+
+    @insert_privilege.setter
+    def insert_privilege(self, value):
+        self._privilege_setters("insert_privilege")
+
+    @upsert_privilege.setter
+    def upsert_privilege(self, value):
+        self._privilege_setters("upsert_privilege")
+
+    @create_privilege.setter
+    def create_privilege(self, value):
+        self._privilege_setters("create_privilege")
+
+    @delete_privilege.setter
+    def delete_privilege(self, value):
+        self._privilege_setters("delete_privilege")
+
+    @all_privileges.setter
+    def all_privileges(self, value):
+        self._privilege_setters("all_privileges")
+
+    def deco_is_superuser(self, target):
+        """Decorator to check if the user is a superuser."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.is_superuser:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You are no super user of the Database and therefor this function is not available.")
+        return wrapper
+
+    def deco_select_privilege(self, target):
+        """Decorator to check if the user has the SELECT privilege."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.select_privilege:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You have no select privilege on the database and therefor this function is not available.")
+        return wrapper
+
+    def deco_update_privilege(self, target):
+        """Decorator to check if the user has the UPDATE privilege."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.update_privilege:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You have no update privilege on the database and therefor this function is not available.")
+        return wrapper
+
+    def deco_insert_privilege(self, target):
+        """Decorator to check if the user has the INSERT privilege."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.insert_privilege:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You have no insert privilege on the database and therefor this function is not available.")
+        return wrapper
+
+    def deco_upsert_privilege(self, target):
+        """Decorator to check if the user has the INSERT and UPDATE privilege."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.upsert_privilege:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You have no upsert privilege on the database and therefor this function is not available.")
+        return wrapper
+
+    def deco_create_privilege(self, target):
+        """Decorator to check if the user has the CREATE privilege."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.create_privilege:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You are no admin user of the Database and therefor this function is not available.")
+        return wrapper
+
+    def deco_delete_privilege(self, target):
+        """Decorator to check if the user has the DELETE privilege."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.delete_privilege:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You have no delete privilege on the database and therefor this function is not available.")
+        return wrapper
+
+    def deco_all_privileges(self, target):
+        """Decorator to check if the user has all (SELECT, UPDATE, INSERT, DELETE, CREATE) privileges."""
+        @functools.wraps(target)
+        def wrapper(*args, **kwargs):
+            if self.all_privileges:
+                return target(*args, **kwargs)
+            else:
+                raise PermissionError("You are no super user of the Database and therefor this function is not available.")
+        return wrapper
+
+
+db_engine = DBEngine()

weatherdb/db/fixtures/RichterParameters.json

@@ -0,0 +1,34 @@
+[
+    {
+        "precipitation_typ": "precip_summer",
+        "e": 0.38,
+        "b_no-protection": 0.345,
+        "b_little-protection": 0.31,
+        "b_protected": 0.28,
+        "b_heavy-protection": 0.245
+    },
+    {
+        "precipitation_typ": "precip_winter",
+        "e": 0.46,
+        "b_no-protection": 0.34,
+        "b_little-protection": 0.28,
+        "b_protected": 0.24,
+        "b_heavy-protection": 0.19
+    },
+    {
+        "precipitation_typ": "mix",
+        "e": 0.55,
+        "b_no-protection": 0.535,
+        "b_little-protection": 0.39,
+        "b_protected": 0.305,
+        "b_heavy-protection": 0.185
+    },
+    {
+        "precipitation_typ": "snow",
+        "e": 0.82,
+        "b_no-protection": 0.72,
+        "b_little-protection": 0.51,
+        "b_protected": 0.33,
+        "b_heavy-protection": 0.21
+    }
+]