carconnectivity-plugin-database 0.1__py3-none-any.whl → 0.1a16__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of carconnectivity-plugin-database might be problematic. Click here for more details.

Files changed (16) hide show
  1. {carconnectivity_plugin_database-0.1.dist-info → carconnectivity_plugin_database-0.1a16.dist-info}/METADATA +2 -2
  2. {carconnectivity_plugin_database-0.1.dist-info → carconnectivity_plugin_database-0.1a16.dist-info}/RECORD +16 -16
  3. carconnectivity_plugins/database/_version.py +2 -2
  4. carconnectivity_plugins/database/agents/charging_agent.py +89 -205
  5. carconnectivity_plugins/database/agents/climatization_agent.py +6 -13
  6. carconnectivity_plugins/database/agents/drive_state_agent.py +96 -148
  7. carconnectivity_plugins/database/agents/state_agent.py +14 -26
  8. carconnectivity_plugins/database/agents/trip_agent.py +37 -48
  9. carconnectivity_plugins/database/model/charging_session.py +7 -7
  10. carconnectivity_plugins/database/model/drive.py +6 -6
  11. carconnectivity_plugins/database/model/vehicle.py +34 -36
  12. carconnectivity_plugins/database/plugin.py +14 -10
  13. {carconnectivity_plugin_database-0.1.dist-info → carconnectivity_plugin_database-0.1a16.dist-info}/WHEEL +0 -0
  14. {carconnectivity_plugin_database-0.1.dist-info → carconnectivity_plugin_database-0.1a16.dist-info}/entry_points.txt +0 -0
  15. {carconnectivity_plugin_database-0.1.dist-info → carconnectivity_plugin_database-0.1a16.dist-info}/licenses/LICENSE +0 -0
  16. {carconnectivity_plugin_database-0.1.dist-info → carconnectivity_plugin_database-0.1a16.dist-info}/top_level.txt +0 -0
carconnectivity_plugins/database/agents/climatization_agent.py CHANGED
@@ -18,11 +18,9 @@ if TYPE_CHECKING:
18
18
  from sqlalchemy.orm.session import Session
19
19
 
20
20
  from carconnectivity.attributes import EnumAttribute
21
- from carconnectivity.vehicle import GenericVehicle
22
21
 
23
22
  from carconnectivity.climatization import Climatization
24
23
 
25
- from carconnectivity_plugins.database.plugin import Plugin
26
24
  from carconnectivity_plugins.database.model.vehicle import Vehicle
27
25
 
28
26
 
@@ -30,21 +28,19 @@ LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents
30
28
 
31
29
 
32
30
  class ClimatizationAgent(BaseAgent):
33
- def __init__(self, database_plugin: Plugin, session_factory: scoped_session[Session], vehicle: Vehicle, carconnectivity_vehicle: GenericVehicle) -> None:
34
- if vehicle is None or carconnectivity_vehicle is None:
31
+ def __init__(self, session_factory: scoped_session[Session], vehicle: Vehicle) -> None:
32
+ if vehicle is None or vehicle.carconnectivity_vehicle is None:
35
33
  raise ValueError("Vehicle or its carconnectivity_vehicle attribute is None")
36
- self.database_plugin: Plugin = database_plugin
37
34
  self.session_factory: scoped_session[Session] = session_factory
38
35
  self.vehicle: Vehicle = vehicle
39
- self.carconnectivity_vehicle: GenericVehicle = carconnectivity_vehicle
40
36
 
41
37
  with self.session_factory() as session:
42
38
  self.last_state: Optional[ClimatizationState] = session.query(ClimatizationState).filter(ClimatizationState.vehicle == vehicle)\
43
39
  .order_by(ClimatizationState.first_date.desc()).first()
44
40
  self.last_state_lock: threading.RLock = threading.RLock()
45
41
 
46
- self.carconnectivity_vehicle.climatization.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
47
- self.__on_state_change(self.carconnectivity_vehicle.climatization.state, Observable.ObserverEvent.UPDATED)
42
+ vehicle.carconnectivity_vehicle.climatization.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
43
+ self.__on_state_change(vehicle.carconnectivity_vehicle.climatization.state, Observable.ObserverEvent.UPDATED)
48
44
  self.session_factory.remove()
49
45
 
50
46
  def __on_state_change(self, element: EnumAttribute[Climatization.ClimatizationState], flags: Observable.ObserverEvent) -> None:
@@ -55,9 +51,8 @@ class ClimatizationAgent(BaseAgent):
55
51
  if self.last_state is not None:
56
52
  self.last_state = session.merge(self.last_state)
57
53
  session.refresh(self.last_state)
58
- if element.last_updated is not None \
59
- and (self.last_state is None or (self.last_state.state != element.value
60
- and element.last_updated > self.last_state.last_date)):
54
+ if (self.last_state is None or self.last_state.state != element.value) \
55
+ and element.last_updated is not None:
61
56
  new_state: ClimatizationState = ClimatizationState(vin=self.vehicle.vin, first_date=element.last_updated,
62
57
  last_date=element.last_updated, state=element.value)
63
58
  try:
@@ -68,7 +63,6 @@ class ClimatizationAgent(BaseAgent):
68
63
  except DatabaseError as err:
69
64
  session.rollback()
70
65
  LOG.error('DatabaseError while adding climatizationstate for vehicle %s to database: %s', self.vehicle.vin, err)
71
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
72
66
 
73
67
  elif self.last_state is not None and self.last_state.state == element.value and element.last_updated is not None:
74
68
  if self.last_state.last_date is None or element.last_updated > self.last_state.last_date:
@@ -79,5 +73,4 @@ class ClimatizationAgent(BaseAgent):
79
73
  except DatabaseError as err:
80
74
  session.rollback()
81
75
  LOG.error('DatabaseError while updating climatizationstate for vehicle %s in database: %s', self.vehicle.vin, err)
82
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
83
76
  self.session_factory.remove()
carconnectivity_plugins/database/agents/drive_state_agent.py CHANGED
@@ -8,7 +8,7 @@ import logging
8
8
  from sqlalchemy.exc import DatabaseError
9
9
 
10
10
  from carconnectivity.observable import Observable
11
- from carconnectivity.drive import ElectricDrive, CombustionDrive
11
+ from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
12
12
 
13
13
  from carconnectivity_plugins.database.agents.base_agent import BaseAgent
14
14
  from carconnectivity_plugins.database.model.drive_level import DriveLevel
@@ -23,9 +23,7 @@ if TYPE_CHECKING:
23
23
 
24
24
  from carconnectivity.attributes import LevelAttribute, RangeAttribute, EnumAttribute, EnergyAttribute, VolumeAttribute, EnergyConsumptionAttribute, \
25
25
  FuelConsumptionAttribute
26
- from carconnectivity.drive import GenericDrive
27
26
 
28
- from carconnectivity_plugins.database.plugin import Plugin
29
27
  from carconnectivity_plugins.database.model.drive import Drive
30
28
 
31
29
 
@@ -33,98 +31,87 @@ LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents
33
31
 
34
32
 
35
33
  class DriveStateAgent(BaseAgent):
36
- def __init__(self, database_plugin: Plugin, session_factory: scoped_session[Session], drive: Drive, carconnectivity_drive: GenericDrive) -> None:
37
- self.database_plugin: Plugin = database_plugin
34
+ def __init__(self, session_factory: scoped_session[Session], drive: Drive) -> None:
35
+ if drive is None or drive.carconnectivity_drive is None:
36
+ raise ValueError("Drive or its carconnectivity_drive attribute is None")
38
37
  self.session_factory: scoped_session[Session] = session_factory
39
38
  self.drive: Drive = drive
40
- self.drive_lock: threading.RLock = threading.RLock()
41
- self.carconnectivity_drive: GenericDrive = carconnectivity_drive
42
- with self.drive_lock:
43
- with self.session_factory() as session:
44
- self.drive = session.merge(self.drive)
45
- session.refresh(self.drive)
46
39
 
47
- if self.drive is None or self.carconnectivity_drive is None:
48
- raise ValueError("Drive or its carconnectivity_drive attribute is None")
49
-
50
- self.carconnectivity_drive.type.add_observer(self.__on_type_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
51
- self.type_lock: threading.RLock = threading.RLock()
52
- self.__on_type_change(self.carconnectivity_drive.type, Observable.ObserverEvent.VALUE_CHANGED)
53
-
54
- self.carconnectivity_drive.range_wltp.add_observer(self.__on_range_wltp_change, Observable.ObserverEvent.VALUE_CHANGED,
55
- on_transaction_end=True)
56
- self.range_wltp_lock: threading.RLock = threading.RLock()
57
- self.__on_range_wltp_change(self.carconnectivity_drive.range_wltp, Observable.ObserverEvent.VALUE_CHANGED)
58
-
59
- if isinstance(self.carconnectivity_drive, ElectricDrive):
60
- self.carconnectivity_drive.battery.total_capacity.add_observer(self.__on_electric_total_capacity_change,
61
- Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
62
- self.total_capacity_lock: threading.RLock = threading.RLock()
63
- self.__on_electric_total_capacity_change(self.carconnectivity_drive.battery.total_capacity, Observable.ObserverEvent.VALUE_CHANGED)
64
-
65
- self.carconnectivity_drive.battery.available_capacity.add_observer(self.__on_electric_available_capacity_change,
66
- Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
67
- self.available_capacity_lock: threading.RLock = threading.RLock()
68
- self.__on_electric_available_capacity_change(self.carconnectivity_drive.battery.available_capacity,
69
- Observable.ObserverEvent.VALUE_CHANGED)
70
-
71
- self.last_electric_consumption: Optional[DriveConsumption] = session.query(DriveConsumption) \
72
- .filter(DriveConsumption.drive_id == self.drive.id).order_by(DriveConsumption.first_date.desc()).first()
73
- self.last_electric_consumption_lock: threading.RLock = threading.RLock()
74
- self.carconnectivity_drive.consumption.add_observer(self.__on_electric_consumption_change,
75
- Observable.ObserverEvent.VALUE_CHANGED)
76
- self.__on_electric_consumption_change(self.carconnectivity_drive.consumption, Observable.ObserverEvent.UPDATED)
77
-
78
- elif isinstance(self.carconnectivity_drive, CombustionDrive):
79
- self.carconnectivity_drive.fuel_tank.available_capacity.add_observer(self.__on_fuel_available_capacity_change,
80
- Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
81
- self.fuel_available_capacity_lock: threading.RLock = threading.RLock()
82
- self.__on_fuel_available_capacity_change(self.carconnectivity_drive.fuel_tank.available_capacity, Observable.ObserverEvent.VALUE_CHANGED)
83
-
84
- self.last_fuel_consumption: Optional[DriveConsumption] = session.query(DriveConsumption) \
85
- .filter(DriveConsumption.drive_id == self.drive.id).order_by(DriveConsumption.first_date.desc()).first()
86
- self.last_fuel_consumption_lock: threading.RLock = threading.RLock()
87
- self.carconnectivity_drive.consumption.add_observer(self.__on_fuel_consumption_change,
88
- Observable.ObserverEvent.VALUE_CHANGED)
89
- self.__on_fuel_consumption_change(self.carconnectivity_drive.consumption, Observable.ObserverEvent.UPDATED)
90
-
91
- self.last_level: Optional[DriveLevel] = session.query(DriveLevel).filter(DriveLevel.drive_id == self.drive.id) \
92
- .order_by(DriveLevel.first_date.desc()).first()
93
- self.last_level_lock: threading.RLock = threading.RLock()
94
- self.last_range: Optional[DriveRange] = session.query(DriveRange).filter(DriveRange.drive_id == self.drive.id) \
95
- .order_by(DriveRange.first_date.desc()).first()
96
- self.last_range_lock: threading.RLock = threading.RLock()
97
- self.last_range_estimated_full: Optional[DriveRangeEstimatedFull] = session.query(DriveRangeEstimatedFull) \
98
- .filter(DriveRangeEstimatedFull.drive_id == self.drive.id).order_by(DriveRangeEstimatedFull.first_date.desc()).first()
99
- self.last_range_estimated_full_lock: threading.RLock = threading.RLock()
100
-
101
- if self.carconnectivity_drive is not None:
102
- self.carconnectivity_drive.level.add_observer(self.__on_level_change, Observable.ObserverEvent.UPDATED)
103
- if self.carconnectivity_drive.level.enabled:
104
- self.__on_level_change(self.carconnectivity_drive.level, Observable.ObserverEvent.UPDATED)
105
-
106
- self.carconnectivity_drive.range.add_observer(self.__on_range_change, Observable.ObserverEvent.UPDATED)
107
- if self.carconnectivity_drive.range.enabled:
108
- self.__on_range_change(self.carconnectivity_drive.range, Observable.ObserverEvent.UPDATED)
109
-
110
- self.carconnectivity_drive.range_estimated_full.add_observer(self.__on_range_estimated_full_change, Observable.ObserverEvent.UPDATED)
111
- if self.carconnectivity_drive.range_estimated_full.enabled:
112
- self.__on_range_estimated_full_change(self.carconnectivity_drive.range_estimated_full, Observable.ObserverEvent.UPDATED)
113
- session_factory.remove()
40
+ drive.carconnectivity_drive.type.add_observer(self.__on_type_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
41
+ self.type_lock: threading.RLock = threading.RLock()
42
+ self.__on_type_change(drive.carconnectivity_drive.type, Observable.ObserverEvent.VALUE_CHANGED)
43
+
44
+ drive.carconnectivity_drive.range_wltp.add_observer(self.__on_range_wltp_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
45
+ self.range_wltp_lock: threading.RLock = threading.RLock()
46
+ self.__on_range_wltp_change(drive.carconnectivity_drive.range_wltp, Observable.ObserverEvent.VALUE_CHANGED)
47
+
48
+ with self.session_factory() as session:
49
+ if isinstance(drive.carconnectivity_drive, ElectricDrive):
50
+ drive.carconnectivity_drive.battery.total_capacity.add_observer(self.__on_electric_total_capacity_change,
51
+ Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
52
+ self.total_capacity_lock: threading.RLock = threading.RLock()
53
+ self.__on_electric_total_capacity_change(drive.carconnectivity_drive.battery.total_capacity, Observable.ObserverEvent.VALUE_CHANGED)
54
+
55
+ drive.carconnectivity_drive.battery.available_capacity.add_observer(self.__on_electric_available_capacity_change,
56
+ Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
57
+ self.available_capacity_lock: threading.RLock = threading.RLock()
58
+ self.__on_electric_available_capacity_change(drive.carconnectivity_drive.battery.available_capacity, Observable.ObserverEvent.VALUE_CHANGED)
59
+
60
+ self.last_electric_consumption: Optional[DriveConsumption] = session.query(DriveConsumption).filter(DriveConsumption.drive_id == drive.id) \
61
+ .order_by(DriveConsumption.first_date.desc()).first()
62
+ self.last_electric_consumption_lock: threading.RLock = threading.RLock()
63
+ drive.carconnectivity_drive.consumption.add_observer(self.__on_electric_consumption_change,
64
+ Observable.ObserverEvent.VALUE_CHANGED)
65
+ self.__on_electric_consumption_change(drive.carconnectivity_drive.consumption, Observable.ObserverEvent.UPDATED)
66
+
67
+ elif isinstance(drive.carconnectivity_drive, CombustionDrive):
68
+ drive.carconnectivity_drive.fuel_tank.available_capacity.add_observer(self.__on_fuel_available_capacity_change,
69
+ Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
70
+ self.fuel_available_capacity_lock: threading.RLock = threading.RLock()
71
+ self.__on_fuel_available_capacity_change(drive.carconnectivity_drive.fuel_tank.available_capacity, Observable.ObserverEvent.VALUE_CHANGED)
72
+
73
+ self.last_fuel_consumption: Optional[DriveConsumption] = session.query(DriveConsumption).filter(DriveConsumption.drive_id == drive.id) \
74
+ .order_by(DriveConsumption.first_date.desc()).first()
75
+ self.last_fuel_consumption_lock: threading.RLock = threading.RLock()
76
+ drive.carconnectivity_drive.consumption.add_observer(self.__on_fuel_consumption_change,
77
+ Observable.ObserverEvent.VALUE_CHANGED)
78
+ self.__on_fuel_consumption_change(drive.carconnectivity_drive.consumption, Observable.ObserverEvent.UPDATED)
79
+
80
+ self.last_level: Optional[DriveLevel] = session.query(DriveLevel).filter(DriveLevel.drive_id == drive.id) \
81
+ .order_by(DriveLevel.first_date.desc()).first()
82
+ self.last_level_lock: threading.RLock = threading.RLock()
83
+ self.last_range: Optional[DriveRange] = session.query(DriveRange).filter(DriveRange.drive_id == drive.id) \
84
+ .order_by(DriveRange.first_date.desc()).first()
85
+ self.last_range_lock: threading.RLock = threading.RLock()
86
+ self.last_range_estimated_full: Optional[DriveRangeEstimatedFull] = session.query(DriveRangeEstimatedFull) \
87
+ .filter(DriveRangeEstimatedFull.drive_id == drive.id).order_by(DriveRangeEstimatedFull.first_date.desc()).first()
88
+ self.last_range_estimated_full_lock: threading.RLock = threading.RLock()
89
+
90
+ drive.carconnectivity_drive.level.add_observer(self.__on_level_change, Observable.ObserverEvent.UPDATED)
91
+ if drive.carconnectivity_drive.level.enabled:
92
+ self.__on_level_change(drive.carconnectivity_drive.level, Observable.ObserverEvent.UPDATED)
93
+
94
+ drive.carconnectivity_drive.range.add_observer(self.__on_range_change, Observable.ObserverEvent.UPDATED)
95
+ if drive.carconnectivity_drive.range.enabled:
96
+ self.__on_range_change(drive.carconnectivity_drive.range, Observable.ObserverEvent.UPDATED)
97
+
98
+ drive.carconnectivity_drive.range_estimated_full.add_observer(self.__on_range_estimated_full_change, Observable.ObserverEvent.UPDATED)
99
+ if drive.carconnectivity_drive.range_estimated_full.enabled:
100
+ self.__on_range_estimated_full_change(drive.carconnectivity_drive.range_estimated_full, Observable.ObserverEvent.UPDATED)
101
+ session_factory.remove()
114
102
 
115
103
  def __on_level_change(self, element: LevelAttribute, flags: Observable.ObserverEvent) -> None:
116
104
  del flags
117
105
  if element.enabled:
118
- with self.last_level_lock, self.drive_lock:
106
+ with self.last_level_lock:
119
107
  with self.session_factory() as session:
120
108
  self.drive = session.merge(self.drive)
121
109
  session.refresh(self.drive)
122
110
  if self.last_level is not None:
123
111
  self.last_level = session.merge(self.last_level)
124
112
  session.refresh(self.last_level)
125
- if element.last_updated is not None \
126
- and (self.last_level is None or (self.last_level.level != element.value
127
- and element.last_updated > self.last_level.last_date)):
113
+ if (self.last_level is None or self.last_level.level != element.value) \
114
+ and element.last_updated is not None:
128
115
  new_level: DriveLevel = DriveLevel(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
129
116
  level=element.value)
130
117
  try:
@@ -135,7 +122,6 @@ class DriveStateAgent(BaseAgent):
135
122
  except DatabaseError as err:
136
123
  session.rollback()
137
124
  LOG.error('DatabaseError while adding level for drive %s to database: %s', self.drive.id, err)
138
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
139
125
  elif self.last_level is not None and self.last_level.level == element.value \
140
126
  and element.last_updated is not None:
141
127
  if self.last_level.last_date is None or element.last_updated > self.last_level.last_date:
@@ -146,22 +132,20 @@ class DriveStateAgent(BaseAgent):
146
132
  except DatabaseError as err:
147
133
  session.rollback()
148
134
  LOG.error('DatabaseError while updating level for drive %s in database: %s', self.drive.id, err)
149
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
150
135
  self.session_factory.remove()
151
136
 
152
137
  def __on_range_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
153
138
  del flags
154
139
  if element.enabled:
155
- with self.last_range_lock, self.drive_lock:
140
+ with self.last_range_lock:
156
141
  with self.session_factory() as session:
157
142
  self.drive = session.merge(self.drive)
158
143
  session.refresh(self.drive)
159
144
  if self.last_range is not None:
160
145
  self.last_range = session.merge(self.last_range)
161
146
  session.refresh(self.last_range)
162
- if element.last_updated is not None \
163
- and (self.last_range is None or (self.last_range.range != element.value
164
- and element.last_updated > self.last_range.last_date)):
147
+ if (self.last_range is None or self.last_range.range != element.value) \
148
+ and element.last_updated is not None:
165
149
  new_range: DriveRange = DriveRange(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
166
150
  range=element.value)
167
151
  try:
@@ -172,7 +156,6 @@ class DriveStateAgent(BaseAgent):
172
156
  except DatabaseError as err:
173
157
  session.rollback()
174
158
  LOG.error('DatabaseError while adding range for drive %s to database: %s', self.drive.id, err)
175
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
176
159
  elif self.last_range is not None and self.last_range.range == element.value \
177
160
  and element.last_updated is not None:
178
161
  if self.last_range.last_date is None or element.last_updated > self.last_range.last_date:
@@ -183,22 +166,20 @@ class DriveStateAgent(BaseAgent):
183
166
  except DatabaseError as err:
184
167
  session.rollback()
185
168
  LOG.error('DatabaseError while updating range for drive %s in database: %s', self.drive.id, err)
186
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
187
169
  self.session_factory.remove()
188
170
 
189
171
  def __on_range_estimated_full_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
190
172
  del flags
191
173
  if element.enabled:
192
- with self.last_range_estimated_full_lock, self.drive_lock:
174
+ with self.last_range_estimated_full_lock:
193
175
  with self.session_factory() as session:
194
176
  self.drive = session.merge(self.drive)
195
177
  session.refresh(self.drive)
196
178
  if self.last_range_estimated_full is not None:
197
179
  self.last_range_estimated_full = session.merge(self.last_range_estimated_full)
198
180
  session.refresh(self.last_range_estimated_full)
199
- if element.last_updated is not None \
200
- and (self.last_range_estimated_full is None or (self.last_range_estimated_full.range_estimated_full != element.value
201
- and element.last_updated > self.last_range_estimated_full.last_date)):
181
+ if (self.last_range_estimated_full is None or self.last_range_estimated_full.range_estimated_full != element.value) \
182
+ and element.last_updated is not None:
202
183
  new_range: DriveRangeEstimatedFull = DriveRangeEstimatedFull(drive_id=self.drive.id, first_date=element.last_updated,
203
184
  last_date=element.last_updated, range_estimated_full=element.value)
204
185
  try:
@@ -209,7 +190,6 @@ class DriveStateAgent(BaseAgent):
209
190
  except DatabaseError as err:
210
191
  session.rollback()
211
192
  LOG.error('DatabaseError while adding range_estimated_full for drive %s to database: %s', self.drive.id, err)
212
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
213
193
  elif self.last_range_estimated_full is not None and self.last_range_estimated_full.range_estimated_full == element.value \
214
194
  and element.last_updated is not None:
215
195
  if self.last_range_estimated_full.last_date is None or element.last_updated > self.last_range_estimated_full.last_date:
@@ -220,102 +200,75 @@ class DriveStateAgent(BaseAgent):
220
200
  except DatabaseError as err:
221
201
  session.rollback()
222
202
  LOG.error('DatabaseError while updating range_estimated_full for drive %s in database: %s', self.drive.id, err)
223
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
224
203
  self.session_factory.remove()
225
204
 
226
205
  def __on_type_change(self, element: EnumAttribute[GenericDrive.Type], flags: Observable.ObserverEvent) -> None:
227
206
  del flags
228
- with self.type_lock, self.drive_lock:
207
+ with self.type_lock:
229
208
  with self.session_factory() as session:
230
209
  self.drive = session.merge(self.drive)
231
210
  session.refresh(self.drive)
232
211
  if element.enabled and element.value is not None and self.drive.type != element.value:
233
- try:
234
- self.drive.type = element.value
235
- session.commit()
236
- except DatabaseError as err:
237
- session.rollback()
238
- LOG.error('DatabaseError while updating type for drive %s to database: %s', self.drive.id, err)
239
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
212
+ self.drive.type = element.value
213
+ session.commit()
240
214
  self.session_factory.remove()
241
215
 
242
216
  def __on_electric_total_capacity_change(self, element: EnergyAttribute, flags: Observable.ObserverEvent) -> None:
243
217
  del flags
244
- with self.total_capacity_lock, self.drive_lock:
218
+ with self.total_capacity_lock:
245
219
  with self.session_factory() as session:
246
220
  self.drive = session.merge(self.drive)
247
221
  session.refresh(self.drive)
248
222
  if element.enabled and element.value is not None and self.drive.capacity_total != element.value:
249
- try:
250
- self.drive.capacity_total = element.value
251
- session.commit()
252
- except DatabaseError as err:
253
- session.rollback()
254
- LOG.error('DatabaseError while updating total capacity for drive %s to database: %s', self.drive.id, err)
255
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
223
+ self.drive.capacity_total = element.value
224
+ session.commit()
256
225
  self.session_factory.remove()
257
226
 
258
227
  def __on_electric_available_capacity_change(self, element: EnergyAttribute, flags: Observable.ObserverEvent) -> None:
259
228
  del flags
260
- with self.available_capacity_lock, self.drive_lock:
229
+ with self.available_capacity_lock:
261
230
  with self.session_factory() as session:
262
231
  self.drive = session.merge(self.drive)
263
232
  session.refresh(self.drive)
264
233
  if element.enabled and element.value is not None and self.drive.capacity != element.value:
265
- try:
266
- self.drive.capacity = element.value
267
- session.commit()
268
- except DatabaseError as err:
269
- session.rollback()
270
- LOG.error('DatabaseError while updating available capacity for drive %s to database: %s', self.drive.id, err)
271
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
234
+ self.drive.capacity = element.value
235
+ session.commit()
272
236
  self.session_factory.remove()
273
237
 
274
238
  def __on_range_wltp_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
275
239
  del flags
276
- with self.range_wltp_lock, self.drive_lock:
240
+ with self.range_wltp_lock:
277
241
  with self.session_factory() as session:
278
242
  self.drive = session.merge(self.drive)
279
243
  session.refresh(self.drive)
280
244
  if element.enabled and element.value is not None and self.drive.wltp_range != element.value:
281
- try:
282
- self.drive.wltp_range = element.value
283
- session.commit()
284
- except DatabaseError as err:
285
- session.rollback()
286
- LOG.error('DatabaseError while updating WLTP range for drive %s to database: %s', self.drive.id, err)
287
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
245
+ self.drive.wltp_range = element.value
246
+ session.commit()
288
247
  self.session_factory.remove()
289
248
 
290
249
  def __on_fuel_available_capacity_change(self, element: VolumeAttribute, flags: Observable.ObserverEvent) -> None:
291
250
  del flags
292
- with self.fuel_available_capacity_lock, self.drive_lock:
251
+ with self.fuel_available_capacity_lock:
293
252
  with self.session_factory() as session:
294
253
  self.drive = session.merge(self.drive)
295
254
  session.refresh(self.drive)
296
255
  if element.enabled and element.value is not None and self.drive.capacity != element.value:
297
- try:
298
- self.drive.capacity = element.value
299
- session.commit()
300
- except DatabaseError as err:
301
- session.rollback()
302
- LOG.error('DatabaseError while updating available capacity for drive %s to database: %s', self.drive.id, err)
303
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
256
+ self.drive.capacity = element.value
257
+ session.commit()
304
258
  self.session_factory.remove()
305
259
 
306
260
  def __on_electric_consumption_change(self, element: EnergyConsumptionAttribute, flags: Observable.ObserverEvent) -> None:
307
261
  del flags
308
262
  if element.enabled:
309
- with self.last_electric_consumption_lock, self.drive_lock:
263
+ with self.last_electric_consumption_lock:
310
264
  with self.session_factory() as session:
311
265
  self.drive = session.merge(self.drive)
312
266
  session.refresh(self.drive)
313
267
  if self.last_electric_consumption is not None:
314
268
  self.last_electric_consumption = session.merge(self.last_electric_consumption)
315
269
  session.refresh(self.last_electric_consumption)
316
- if element.last_updated is not None \
317
- and (self.last_electric_consumption is None or (self.last_electric_consumption.consumption != element.value
318
- and element.last_updated > self.last_electric_consumption.last_date)):
270
+ if (self.last_electric_consumption is None or self.last_electric_consumption.consumption != element.value) \
271
+ and element.last_updated is not None:
319
272
  new_level: DriveConsumption = DriveConsumption(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
320
273
  consumption=element.value)
321
274
  try:
@@ -326,7 +279,6 @@ class DriveStateAgent(BaseAgent):
326
279
  except DatabaseError as err:
327
280
  session.rollback()
328
281
  LOG.error('DatabaseError while adding consumption for drive %s to database: %s', self.drive.id, err)
329
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
330
282
  elif self.last_electric_consumption is not None and self.last_electric_consumption.consumption == element.value \
331
283
  and element.last_updated is not None:
332
284
  if self.last_electric_consumption.last_date is None or element.last_updated > self.last_electric_consumption.last_date:
@@ -337,22 +289,20 @@ class DriveStateAgent(BaseAgent):
337
289
  except DatabaseError as err:
338
290
  session.rollback()
339
291
  LOG.error('DatabaseError while updating consumption for drive %s in database: %s', self.drive.id, err)
340
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
341
292
  self.session_factory.remove()
342
293
 
343
294
  def __on_fuel_consumption_change(self, element: FuelConsumptionAttribute, flags: Observable.ObserverEvent) -> None:
344
295
  del flags
345
296
  if element.enabled:
346
- with self.last_fuel_consumption_lock, self.drive_lock:
297
+ with self.last_fuel_consumption_lock:
347
298
  with self.session_factory() as session:
348
299
  self.drive = session.merge(self.drive)
349
300
  session.refresh(self.drive)
350
301
  if self.last_fuel_consumption is not None:
351
302
  self.last_fuel_consumption = session.merge(self.last_fuel_consumption)
352
303
  session.refresh(self.last_fuel_consumption)
353
- if element.last_updated is not None \
354
- and (self.last_fuel_consumption is None or (self.last_fuel_consumption.consumption != element.value
355
- and element.last_updated > self.last_fuel_consumption.last_date)):
304
+ if (self.last_fuel_consumption is None or self.last_fuel_consumption.consumption != element.value) \
305
+ and element.last_updated is not None:
356
306
  new_level: DriveConsumption = DriveConsumption(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
357
307
  consumption=element.value)
358
308
  try:
@@ -363,7 +313,6 @@ class DriveStateAgent(BaseAgent):
363
313
  except DatabaseError as err:
364
314
  session.rollback()
365
315
  LOG.error('DatabaseError while adding consumption for drive %s to database: %s', self.drive.id, err)
366
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
367
316
  elif self.last_fuel_consumption is not None and self.last_fuel_consumption.consumption == element.value \
368
317
  and element.last_updated is not None:
369
318
  if self.last_fuel_consumption.last_date is None or element.last_updated > self.last_fuel_consumption.last_date:
@@ -374,5 +323,4 @@ class DriveStateAgent(BaseAgent):
374
323
  except DatabaseError as err:
375
324
  session.rollback()
376
325
  LOG.error('DatabaseError while updating consumption for drive %s in database: %s', self.drive.id, err)
377
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
378
326
  self.session_factory.remove()
carconnectivity_plugins/database/agents/state_agent.py CHANGED
@@ -23,7 +23,6 @@ if TYPE_CHECKING:
23
23
 
24
24
  from carconnectivity.vehicle import GenericVehicle
25
25
 
26
- from carconnectivity_plugins.database.plugin import Plugin
27
26
  from carconnectivity_plugins.database.model.vehicle import Vehicle
28
27
 
29
28
 
@@ -31,13 +30,11 @@ LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents
31
30
 
32
31
 
33
32
  class StateAgent(BaseAgent):
34
- def __init__(self, database_plugin: Plugin, session_factory: scoped_session[Session], vehicle: Vehicle, carconnectivity_vehicle: GenericVehicle) -> None:
35
- if vehicle is None or carconnectivity_vehicle is None:
33
+ def __init__(self, session_factory: scoped_session[Session], vehicle: Vehicle) -> None:
34
+ if vehicle is None or vehicle.carconnectivity_vehicle is None:
36
35
  raise ValueError("Vehicle or its carconnectivity_vehicle attribute is None")
37
- self.database_plugin: Plugin = database_plugin
38
36
  self.session_factory: scoped_session[Session] = session_factory
39
37
  self.vehicle: Vehicle = vehicle
40
- self.carconnectivity_vehicle: GenericVehicle = carconnectivity_vehicle
41
38
 
42
39
  with self.session_factory() as session:
43
40
  self.last_state: Optional[State] = session.query(State).filter(State.vehicle == vehicle).order_by(State.first_date.desc()).first()
@@ -51,14 +48,14 @@ class StateAgent(BaseAgent):
51
48
  .order_by(OutsideTemperature.first_date.desc()).first()
52
49
  self.last_outside_temperature_lock: threading.RLock = threading.RLock()
53
50
 
54
- self.carconnectivity_vehicle.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
55
- self.__on_state_change(self.carconnectivity_vehicle.state, Observable.ObserverEvent.UPDATED)
51
+ vehicle.carconnectivity_vehicle.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
52
+ self.__on_state_change(vehicle.carconnectivity_vehicle.state, Observable.ObserverEvent.UPDATED)
56
53
 
57
- self.carconnectivity_vehicle.connection_state.add_observer(self.__on_connection_state_change, Observable.ObserverEvent.UPDATED)
58
- self.__on_connection_state_change(self.carconnectivity_vehicle.connection_state, Observable.ObserverEvent.UPDATED)
54
+ vehicle.carconnectivity_vehicle.connection_state.add_observer(self.__on_connection_state_change, Observable.ObserverEvent.UPDATED)
55
+ self.__on_connection_state_change(vehicle.carconnectivity_vehicle.connection_state, Observable.ObserverEvent.UPDATED)
59
56
 
60
- self.carconnectivity_vehicle.outside_temperature.add_observer(self.__on_outside_temperature_change, Observable.ObserverEvent.UPDATED)
61
- self.__on_outside_temperature_change(self.carconnectivity_vehicle.outside_temperature, Observable.ObserverEvent.UPDATED)
57
+ vehicle.carconnectivity_vehicle.outside_temperature.add_observer(self.__on_outside_temperature_change, Observable.ObserverEvent.UPDATED)
58
+ self.__on_outside_temperature_change(vehicle.carconnectivity_vehicle.outside_temperature, Observable.ObserverEvent.UPDATED)
62
59
  self.session_factory.remove()
63
60
 
64
61
  def __on_state_change(self, element: EnumAttribute[GenericVehicle.State], flags: Observable.ObserverEvent) -> None:
@@ -69,9 +66,8 @@ class StateAgent(BaseAgent):
69
66
  if self.last_state is not None:
70
67
  self.last_state = session.merge(self.last_state)
71
68
  session.refresh(self.last_state)
72
- if element.last_updated is not None \
73
- and (self.last_state is None or (self.last_state.state != element.value
74
- and element.last_updated > self.last_state.last_date)):
69
+ if (self.last_state is None or self.last_state.state != element.value) \
70
+ and element.last_updated is not None:
75
71
  new_state: State = State(vin=self.vehicle.vin, first_date=element.last_updated, last_date=element.last_updated, state=element.value)
76
72
  try:
77
73
  session.add(new_state)
@@ -81,7 +77,6 @@ class StateAgent(BaseAgent):
81
77
  except DatabaseError as err:
82
78
  session.rollback()
83
79
  LOG.error('DatabaseError while adding state for vehicle %s to database: %s', self.vehicle.vin, err)
84
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
85
80
 
86
81
  elif self.last_state is not None and self.last_state.state == element.value and element.last_updated is not None:
87
82
  if self.last_state.last_date is None or element.last_updated > self.last_state.last_date:
@@ -92,7 +87,6 @@ class StateAgent(BaseAgent):
92
87
  except DatabaseError as err:
93
88
  session.rollback()
94
89
  LOG.error('DatabaseError while updating state for vehicle %s in database: %s', self.vehicle.vin, err)
95
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
96
90
  self.session_factory.remove()
97
91
 
98
92
  def __on_connection_state_change(self, element: EnumAttribute[GenericVehicle.ConnectionState], flags: Observable.ObserverEvent) -> None:
@@ -103,9 +97,8 @@ class StateAgent(BaseAgent):
103
97
  if self.last_connection_state is not None:
104
98
  self.last_connection_state = session.merge(self.last_connection_state)
105
99
  session.refresh(self.last_connection_state)
106
- if element.last_updated is not None \
107
- and (self.last_connection_state is None or (self.last_connection_state.connection_state != element.value
108
- and element.last_updated > self.last_connection_state.last_date)):
100
+ if (self.last_connection_state is None or self.last_connection_state.connection_state != element.value) \
101
+ and element.last_updated is not None:
109
102
  new_connection_state: ConnectionState = ConnectionState(vin=self.vehicle.vin, first_date=element.last_updated,
110
103
  last_date=element.last_updated, connection_state=element.value)
111
104
  try:
@@ -116,7 +109,6 @@ class StateAgent(BaseAgent):
116
109
  except DatabaseError as err:
117
110
  session.rollback()
118
111
  LOG.error('DatabaseError while adding connection state for vehicle %s to database: %s', self.vehicle.vin, err)
119
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
120
112
  elif self.last_connection_state is not None and self.last_connection_state.connection_state == element.value \
121
113
  and element.last_updated is not None:
122
114
  if self.last_connection_state.last_date is None or element.last_updated > self.last_connection_state.last_date:
@@ -127,7 +119,6 @@ class StateAgent(BaseAgent):
127
119
  except DatabaseError as err:
128
120
  session.rollback()
129
121
  LOG.error('DatabaseError while updating connection state for vehicle %s in database: %s', self.vehicle.vin, err)
130
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
131
122
  self.session_factory.remove()
132
123
 
133
124
  def __on_outside_temperature_change(self, element: TemperatureAttribute, flags: Observable.ObserverEvent) -> None:
@@ -138,9 +129,8 @@ class StateAgent(BaseAgent):
138
129
  if self.last_outside_temperature is not None:
139
130
  self.last_outside_temperature = session.merge(self.last_outside_temperature)
140
131
  session.refresh(self.last_outside_temperature)
141
- if element.last_updated is not None \
142
- and (self.last_outside_temperature is None or (self.last_outside_temperature.outside_temperature != element.value
143
- and element.last_updated > self.last_outside_temperature.last_date)):
132
+ if (self.last_outside_temperature is None or self.last_outside_temperature.outside_temperature != element.value) \
133
+ and element.last_updated is not None:
144
134
  new_outside_temperature: OutsideTemperature = OutsideTemperature(vin=self.vehicle.vin, first_date=element.last_updated,
145
135
  last_date=element.last_updated, outside_temperature=element.value)
146
136
  try:
@@ -151,7 +141,6 @@ class StateAgent(BaseAgent):
151
141
  except DatabaseError as err:
152
142
  session.rollback()
153
143
  LOG.error('DatabaseError while adding outside temperature for vehicle %s to database: %s', self.vehicle.vin, err)
154
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
155
144
  elif self.last_outside_temperature is not None and self.last_outside_temperature.outside_temperature == element.value \
156
145
  and element.last_updated is not None:
157
146
  if self.last_outside_temperature.last_date is None or element.last_updated > self.last_outside_temperature.last_date:
@@ -162,5 +151,4 @@ class StateAgent(BaseAgent):
162
151
  except DatabaseError as err:
163
152
  session.rollback()
164
153
  LOG.error('DatabaseError while updating outside temperature for vehicle %s in database: %s', self.vehicle.vin, err)
165
- self.database_plugin.healthy._set_value(value=False) # pylint: disable=protected-access
166
154
  self.session_factory.remove()