quakemap-backend/env.py at dmdata · RealAllenDa/quakemap-backend · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
from internal.centroid import Centroid
from internal.db import Database
from internal.dmdata import DMDataFetcher
from internal.geojson import GeoJson
from internal.intensity2color import IntensityToColor
from internal.pswave import PSWave
from schemas.config import ConfigModel, RunEnvironment

__all__ = ["Env"]

from sdk import verify_none, verify_type, verify_not_used


class _Env:
    """
    Shared variables across project.
    """

    def __init__(self) -> None:
        self.version = "3.2.1"
        self._run_env = None
        self._init_time = None
        self._config = None
        self._geojson_instance = None
        self._centroid_instance = None
        self._intensity_to_color_instance = None
        self._pswave_instance = None
        self._dmdata_instance = None
        self._db_instance = None

    @property
    def run_env(self) -> RunEnvironment:
        verify_none(self._run_env)
        return self._run_env

    @run_env.setter
    def run_env(self, env: RunEnvironment):
        if self._run_env is not None:
            verify_not_used("run_env", "repetitively set")
        verify_type(env, RunEnvironment)
        self._run_env = env

    @property
    def init_time(self) -> int:
        verify_none(self._init_time)
        return self._init_time

    # noinspection PyUnusedLocal
    @init_time.setter
    def init_time(self, value: int) -> None:
        if self._init_time is not None:
            verify_not_used("init_time", "repetitively set")
        verify_type(value, int)
        self._init_time = value

    @property
    def config(self) -> ConfigModel:
        verify_none(self._config)
        return self._config

    @config.setter
    def config(self, config: ConfigModel) -> None:
        verify_type(config, ConfigModel)
        self._config = config

    @property
    def geojson_instance(self) -> GeoJson:
        verify_none(self._geojson_instance)
        return self._geojson_instance

    @geojson_instance.setter
    def geojson_instance(self, instance: GeoJson) -> None:
        verify_type(instance, GeoJson)
        self._geojson_instance = instance

    @property
    def centroid_instance(self) -> Centroid:
        verify_none(self._centroid_instance)
        return self._centroid_instance

    @centroid_instance.setter
    def centroid_instance(self, instance: Centroid) -> None:
        verify_type(instance, Centroid)
        self._centroid_instance = instance

    @property
    def intensity2color_instance(self) -> IntensityToColor:
        verify_none(self._intensity_to_color_instance)
        return self._intensity_to_color_instance

    @intensity2color_instance.setter
    def intensity2color_instance(self, instance: IntensityToColor) -> None:
        verify_type(instance, IntensityToColor)
        self._intensity_to_color_instance = instance

    @property
    def pswave_instance(self) -> PSWave:
        verify_none(self._pswave_instance)
        return self._pswave_instance

    @pswave_instance.setter
    def pswave_instance(self, instance: PSWave) -> None:
        verify_type(instance, PSWave)
        self._pswave_instance = instance

    @property
    def dmdata_instance(self) -> DMDataFetcher:
        verify_none(self._dmdata_instance)
        return self._dmdata_instance

    @dmdata_instance.setter
    def dmdata_instance(self, instance: DMDataFetcher) -> None:
        verify_type(instance, DMDataFetcher)
        self._dmdata_instance = instance

    @property
    def db_instance(self) -> Database:
        verify_none(self._db_instance)
        return self._db_instance

    @db_instance.setter
    def db_instance(self, instance: Database):
        verify_type(instance, Database)
        self._db_instance = instance

    @property
    def eew_debugging_enabled(self) -> bool:
        return Env.config.debug.kmoni_eew.enabled or \
            Env.config.debug.svir_eew.enabled or \
            Env.config.debug.iedred_eew.enabled


Env = _Env()