Corrections in persistence, distribution_systems_electrical_consumption property seems to be bugged

hub/city_model_structure/building.py

@@ -743,8 +743,10 @@ class Building(CityObject):
 
       for key, item in self._distribution_systems_electrical_consumption.items():
         for i in range(0, len(item)):
-          self._distribution_systems_electrical_consumption[key][i] += _peak_load * _consumption_fix_flow \
+          self._distribution_systems_electrical_consumption[key][i] += (
-                                                                       * _working_hours[key] * cte.WATTS_HOUR_TO_JULES
+            _peak_load * _consumption_fix_flow * _working_hours[key] * cte.WATTS_HOUR_TO_JULES
+          )
+
     return self._distribution_systems_electrical_consumption
 
   def _calculate_consumption(self, consumption_type, demand):

hub/persistence/db_control.py

@@ -114,10 +114,7 @@ class DBControl:
       result_names = []
     results = {}
     for scenario in request_values['scenarios']:
-      print('scenario', scenario, results)
       for scenario_name in scenario.keys():
-        print('scenario name', scenario_name)
-
         result_sets = self._city.get_by_user_id_application_id_and_scenario(
           user_id,
           application_id,
@@ -143,7 +140,6 @@ class DBControl:
               values = json.loads(value.values)
               values["building"] = building_name
               results[scenario_name].append(values)
-      print(scenario, results)
     return results
 
   def persist_city(self, city: City, pickle_path, scenario, application_id: int, user_id: int):

hub/persistence/models/application.py

@@ -7,9 +7,10 @@ Project Coder Guille Gutierrez Guillermo.GutierrezMorote@concordia.ca
 
 import datetime
 
-from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy import Column, Integer, String, Sequence
 from sqlalchemy import DateTime
+from sqlalchemy.dialects.postgresql import UUID
+
 from hub.persistence.configuration import Models
 
 

hub/persistence/models/city.py

@@ -21,8 +21,8 @@ class City(Models):
   pickle_path = Column(String, nullable=False)
   name = Column(String, nullable=False)
   scenario = Column(String, nullable=False)
-  application_id = Column(Integer, ForeignKey('application.id'), nullable=False)
+  application_id = Column(Integer, ForeignKey('application.id', ondelete='CASCADE'), nullable=False)
-  user_id = Column(Integer, ForeignKey('user.id'), nullable=True)
+  user_id = Column(Integer, ForeignKey('user.id', ondelete='CASCADE'), nullable=True)
   hub_release = Column(String, nullable=False)
   created = Column(DateTime, default=datetime.datetime.utcnow)
   updated = Column(DateTime, default=datetime.datetime.utcnow)

hub/persistence/models/city_object.py

@@ -21,7 +21,7 @@ class CityObject(Models):
   """
   __tablename__ = 'city_object'
   id = Column(Integer, Sequence('city_object_id_seq'), primary_key=True)
-  city_id = Column(Integer, ForeignKey('city.id'), nullable=False)
+  city_id = Column(Integer, ForeignKey('city.id', ondelete='CASCADE'), nullable=False)
   name = Column(String, nullable=False)
   aliases = Column(String, nullable=True)
   type = Column(String, nullable=False)

hub/persistence/models/simulation_results.py

@@ -19,8 +19,8 @@ class SimulationResults(Models):
   """
   __tablename__ = 'simulation_results'
   id = Column(Integer, Sequence('simulation_results_id_seq'), primary_key=True)
-  city_id = Column(Integer, ForeignKey('city.id'), nullable=True)
+  city_id = Column(Integer, ForeignKey('city.id', ondelete='CASCADE'), nullable=True)
-  city_object_id = Column(Integer, ForeignKey('city_object.id'), nullable=True)
+  city_object_id = Column(Integer, ForeignKey('city_object.id', ondelete='CASCADE'), nullable=True)
   name = Column(String, nullable=False)
   values = Column(JSONB, nullable=False)
   created = Column(DateTime, default=datetime.datetime.utcnow)

hub/persistence/repositories/application.py

@@ -10,6 +10,7 @@ import logging
 
 from sqlalchemy import select
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm.session import Session
 
 from hub.persistence.repository import Repository
 from hub.persistence.models import Application as Model
@@ -48,10 +49,11 @@ class Application(Repository):
       pass
     try:
       application = Model(name=name, description=description, application_uuid=application_uuid)
-      self.session.add(application)
+      with Session(self.engine) as session:
-      self.session.commit()
+        session.add(application)
-      self.session.refresh(application)
+        session.commit()
-      return application.id
+        session.refresh(application)
+        return application.id
     except SQLAlchemyError as err:
       logging.error('An error occurred while creating application %s', err)
       raise SQLAlchemyError from err
@@ -65,10 +67,11 @@ class Application(Repository):
     :return: None
     """
     try:
-      self.session.query(Model).filter(
+      with Session(self.engine) as session:
-        Model.application_uuid == application_uuid
+        session.query(Model).filter(
-      ).update({'name': name, 'description': description, 'updated': datetime.datetime.utcnow()})
+          Model.application_uuid == application_uuid
-      self.session.commit()
+        ).update({'name': name, 'description': description, 'updated': datetime.datetime.utcnow()})
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while updating application %s', err)
       raise SQLAlchemyError from err
@@ -80,9 +83,10 @@ class Application(Repository):
     :return: None
     """
     try:
-      self.session.query(Model).filter(Model.application_uuid == application_uuid).delete()
+      with Session(self.engine) as session:
-      self.session.flush()
+        session.query(Model).filter(Model.application_uuid == application_uuid).delete()
-      self.session.commit()
+        session.flush()
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while deleting application %s', err)
       raise SQLAlchemyError from err
@@ -94,10 +98,11 @@ class Application(Repository):
     :return: Application with the provided application_uuid
     """
     try:
-      result_set = self.session.execute(select(Model).where(
+      with Session(self.engine) as session:
-        Model.application_uuid == application_uuid)
+        result_set = session.execute(select(Model).where(
-      ).first()
+          Model.application_uuid == application_uuid)
-      return result_set[0]
+        ).first()
+        return result_set[0]
     except SQLAlchemyError as err:
       logging.error('Error while fetching application by application_uuid %s', err)
       raise SQLAlchemyError from err

hub/persistence/repositories/city.py

@@ -54,18 +54,18 @@ class City(Repository):
         application_id,
         user_id,
         __version__)
-
+      with Session(self.engine) as session:
-      self.session.add(db_city)
+        session.add(db_city)
-      self.session.flush()
+        session.flush()
-      self.session.commit()
+        session.commit()
-      for building in city.buildings:
+        for building in city.buildings:
-        db_city_object = CityObject(db_city.id,
+          db_city_object = CityObject(db_city.id,
-                                    building)
+                                      building)
-        self.session.add(db_city_object)
+          session.add(db_city_object)
-        self.session.flush()
+          session.flush()
-      self.session.commit()
+        session.commit()
-      self.session.refresh(db_city)
+        session.refresh(db_city)
-      return db_city.id
+        return db_city.id
     except SQLAlchemyError as err:
       logging.error('An error occurred while creating a city %s', err)
       raise SQLAlchemyError from err
@@ -79,8 +79,9 @@ class City(Repository):
     """
     try:
       now = datetime.datetime.utcnow()
-      self.session.query(Model).filter(Model.id == city_id).update({'name': city.name, 'updated': now})
+      with Session(self.engine) as session:
-      self.session.commit()
+        session.query(Model).filter(Model.id == city_id).update({'name': city.name, 'updated': now})
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while updating city %s', err)
       raise SQLAlchemyError from err
@@ -92,9 +93,10 @@ class City(Repository):
     :return: None
     """
     try:
-      self.session.query(CityObject).filter(CityObject.city_id == city_id).delete()
+      with Session(self.engine) as session:
-      self.session.query(Model).filter(Model.id == city_id).delete()
+        session.query(CityObject).filter(CityObject.city_id == city_id).delete()
-      self.session.commit()
+        session.query(Model).filter(Model.id == city_id).delete()
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while fetching city %s', err)
       raise SQLAlchemyError from err
@@ -108,13 +110,12 @@ class City(Repository):
     :return: [ModelCity]
     """
     try:
-      result_set = self.session.execute(select(Model).where(Model.user_id == user_id,
+      with Session(self.engine) as session:
-                                                            Model.application_id == application_id,
+        result_set = session.execute(select(Model).where(Model.user_id == user_id,
-                                                            Model.scenario == scenario
+                                                              Model.application_id == application_id,
-                                                            )).all()
+                                                              Model.scenario == scenario
-      self.session.close()
+                                                              )).all()
-      self.session = Session(self.engine)
+        return result_set
-      return result_set
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by name %s', err)
       raise SQLAlchemyError from err
@@ -127,10 +128,11 @@ class City(Repository):
     :return: ModelCity
     """
     try:
-      result_set = self.session.execute(
+      with Session(self.engine) as session:
-        select(Model).where(Model.user_id == user_id, Model.application_id == application_id)
+        result_set = session.execute(
-      )
+          select(Model).where(Model.user_id == user_id, Model.application_id == application_id)
-      return [r[0] for r in result_set]
+        )
+        return [r[0] for r in result_set]
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by name %s', err)
       raise SQLAlchemyError from err

hub/persistence/repositories/city_object.py

@@ -46,10 +46,11 @@ class CityObject(Repository):
     try:
       city_object = Model(city_id=city_id,
                           building=building)
-      self.session.add(city_object)
+      with Session(self.engine) as session:
-      self.session.flush()
+        session.add(city_object)
-      self.session.commit()
+        session.flush()
-      self.session.refresh(city_object)
+        session.commit()
+        session.refresh(city_object)
       return city_object.id
     except SQLAlchemyError as err:
       logging.error('An error occurred while creating city_object %s', err)
@@ -68,17 +69,18 @@ class CityObject(Repository):
         for usage in internal_zone.usages:
           object_usage = f'{object_usage}{usage.name}_{usage.percentage} '
       object_usage = object_usage.rstrip()
-      self.session.query(Model).filter(Model.name == building.name, Model.city_id == city_id).update(
+      with Session(self.engine) as session:
-        {'name': building.name,
+        session.query(Model).filter(Model.name == building.name, Model.city_id == city_id).update(
-         'alias': building.alias,
+          {'name': building.name,
-         'object_type': building.type,
+           'alias': building.alias,
-         'year_of_construction': building.year_of_construction,
+           'object_type': building.type,
-         'function': building.function,
+           'year_of_construction': building.year_of_construction,
-         'usage': object_usage,
+           'function': building.function,
-         'volume': building.volume,
+           'usage': object_usage,
-         'area': building.floor_area,
+           'volume': building.volume,
-         'updated': datetime.datetime.utcnow()})
+           'area': building.floor_area,
-      self.session.commit()
+           'updated': datetime.datetime.utcnow()})
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while updating city object %s', err)
       raise SQLAlchemyError from err
@@ -91,8 +93,9 @@ class CityObject(Repository):
     :return: None
     """
     try:
-      self.session.query(Model).filter(Model.city_id == city_id, Model.name == name).delete()
+      with Session(self.engine) as session:
-      self.session.commit()
+        session.query(Model).filter(Model.city_id == city_id, Model.name == name).delete()
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while deleting application %s', err)
       raise SQLAlchemyError from err
@@ -106,15 +109,14 @@ class CityObject(Repository):
     """
     try:
       # search by name first
-      city_object = self.session.execute(select(Model).where(Model.name == name, Model.city_id == city_id)).first()
+      with Session(self.engine) as session:
-      if city_object is not None:
+        city_object = session.execute(select(Model).where(Model.name == name, Model.city_id == city_id)).first()
-        return city_object[0]
+        if city_object is not None:
-      # name not found, so search by alias instead
+          return city_object[0]
-      city_objects = self.session.execute(
+        # name not found, so search by alias instead
-        select(Model).where(Model.aliases.contains(name), Model.city_id == city_id)
+        city_objects = session.execute(
-      ).all()
+          select(Model).where(Model.aliases.contains(name), Model.city_id == city_id)
-      self.session.close()
+        ).all()
-      self.session = Session(self.engine)
       for city_object in city_objects:
         aliases = city_object[0].aliases.replace('{', '').replace('}', '').split(',')
         for alias in aliases:

hub/persistence/repositories/simulation_results.py

@@ -10,6 +10,7 @@ import logging
 from sqlalchemy import or_
 from sqlalchemy import select
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
 
 from hub.persistence.repository import Repository
 from hub.persistence.models import City
@@ -52,11 +53,12 @@ class SimulationResults(Repository):
                                 values=values,
                                 city_id=city_id,
                                 city_object_id=city_object_id)
-      self.session.add(simulation_result)
+      with Session(self.engine) as session:
-      self.session.flush()
+        session.add(simulation_result)
-      self.session.commit()
+        session.flush()
-      self.session.refresh(simulation_result)
+        session.commit()
-      return simulation_result.id
+        session.refresh(simulation_result)
+        return simulation_result.id
     except SQLAlchemyError as err:
       logging.error('An error occurred while creating city_object %s', err)
       raise SQLAlchemyError from err
@@ -71,22 +73,23 @@ class SimulationResults(Repository):
     :return: None
     """
     try:
-      if city_id is not None:
+      with Session(self.engine) as session:
-        self.session.query(Model).filter(Model.name == name, Model.city_id == city_id).update(
+        if city_id is not None:
+          session.query(Model).filter(Model.name == name, Model.city_id == city_id).update(
           {
             'values': values,
             'updated': datetime.datetime.utcnow()
           })
-        self.session.commit()
+          session.commit()
-      elif city_object_id is not None:
+        elif city_object_id is not None:
-        self.session.query(Model).filter(Model.name == name, Model.city_object_id == city_object_id).update(
+          session.query(Model).filter(Model.name == name, Model.city_object_id == city_object_id).update(
-          {
+            {
-            'values': values,
+              'values': values,
-            'updated': datetime.datetime.utcnow()
+              'updated': datetime.datetime.utcnow()
-          })
+            })
-        self.session.commit()
+          session.commit()
-      else:
+        else:
-        raise NotImplementedError('Missing either city_id or city_object_id')
+          raise NotImplementedError('Missing either city_id or city_object_id')
     except SQLAlchemyError as err:
       logging.error('Error while updating city object %s', err)
       raise SQLAlchemyError from err
@@ -100,14 +103,15 @@ class SimulationResults(Repository):
     :return: None
     """
     try:
-      if city_id is not None:
+      with Session(self.engine) as session:
-        self.session.query(Model).filter(Model.name == name, Model.city_id == city_id).delete()
+        if city_id is not None:
-        self.session.commit()
+          session.query(Model).filter(Model.name == name, Model.city_id == city_id).delete()
-      elif city_object_id is not None:
+          session.commit()
-        self.session.query(Model).filter(Model.name == name, Model.city_object_id == city_object_id).delete()
+        elif city_object_id is not None:
-        self.session.commit()
+          session.query(Model).filter(Model.name == name, Model.city_object_id == city_object_id).delete()
-      else:
+          session.commit()
-        raise NotImplementedError('Missing either city_id or city_object_id')
+        else:
+          raise NotImplementedError('Missing either city_id or city_object_id')
     except SQLAlchemyError as err:
       logging.error('Error while deleting application: %s', err)
       raise SQLAlchemyError from err
@@ -119,7 +123,8 @@ class SimulationResults(Repository):
     :return: [City] with the provided city_id
     """
     try:
-      return self.session.execute(select(City).where(City.id == city_id)).first()
+      with Session(self.engine) as session:
+        return session.execute(select(City).where(City.id == city_id)).first()
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by city_id: %s', err)
       raise SQLAlchemyError from err
@@ -131,7 +136,8 @@ class SimulationResults(Repository):
     :return: [CityObject] with the provided city_object_id
     """
     try:
-      return self.session.execute(select(CityObject).where(CityObject.id == city_object_id)).first()
+      with Session(self.engine) as session:
+        return session.execute(select(CityObject).where(CityObject.id == city_object_id)).first()
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by city_id: %s', err)
       raise SQLAlchemyError from err
@@ -145,18 +151,19 @@ class SimulationResults(Repository):
     :return: [SimulationResult]
     """
     try:
-      result_set = self.session.execute(select(Model).where(or_(
+      with Session(self.engine) as session:
-        Model.city_id == city_id,
+        result_set = session.execute(select(Model).where(or_(
-        Model.city_object_id == city_object_id
+          Model.city_id == city_id,
-      )))
+          Model.city_object_id == city_object_id
-      results = [r[0] for r in result_set]
+        )))
-      if not result_names:
+        results = [r[0] for r in result_set]
-        return results
+        if not result_names:
-      filtered_results = []
+          return results
-      for result in results:
+        filtered_results = []
-        if result.name in result_names:
+        for result in results:
-          filtered_results.append(result)
+          if result.name in result_names:
-      return filtered_results
+            filtered_results.append(result)
+        return filtered_results
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by city_id: %s', err)
       raise SQLAlchemyError from err

hub/persistence/repositories/user.py

@@ -9,6 +9,7 @@ import logging
 
 from sqlalchemy import select
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
 
 from hub.helpers.auth import Auth
 from hub.persistence.repository import Repository
@@ -49,10 +50,11 @@ class User(Repository):
       pass
     try:
       user = Model(name=name, password=Auth.hash_password(password), role=role, application_id=application_id)
-      self.session.add(user)
+      with Session(self.engine) as session:
-      self.session.flush()
+        session.add(user)
-      self.session.commit()
+        session.flush()
-      self.session.refresh(user)
+        session.commit()
+        session.refresh(user)
       return user.id
     except SQLAlchemyError as err:
       logging.error('An error occurred while creating user %s', err)
@@ -68,13 +70,14 @@ class User(Repository):
     :return: None
     """
     try:
-      self.session.query(Model).filter(Model.id == user_id).update({
+      with Session(self.engine) as session:
-        'name': name,
+        session.query(Model).filter(Model.id == user_id).update({
-        'password': Auth.hash_password(password),
+          'name': name,
-        'role': role,
+          'password': Auth.hash_password(password),
-        'updated': datetime.datetime.utcnow()
+          'role': role,
-      })
+          'updated': datetime.datetime.utcnow()
-      self.session.commit()
+        })
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while updating user: %s', err)
       raise SQLAlchemyError from err
@@ -86,8 +89,9 @@ class User(Repository):
     :return: None
     """
     try:
-      self.session.query(Model).filter(Model.id == user_id).delete()
+      with Session(self.engine) as session:
-      self.session.commit()
+        session.query(Model).filter(Model.id == user_id).delete()
+        session.commit()
     except SQLAlchemyError as err:
       logging.error('Error while fetching user: %s', err)
       raise SQLAlchemyError from err
@@ -100,10 +104,12 @@ class User(Repository):
     :return: User matching the search criteria or None
     """
     try:
-      user = self.session.execute(
+      with Session(self.engine) as session:
-        select(Model).where(Model.name == name, Model.application_id == application_id)
+        user = session.execute(
-      ).first()
+          select(Model).where(Model.name == name, Model.application_id == application_id)
-      return user[0]
+        ).first()
+        session.commit()
+        return user[0]
     except SQLAlchemyError as err:
       logging.error('Error while fetching user by name and application: %s', err)
       raise SQLAlchemyError from err
@@ -120,12 +126,13 @@ class User(Repository):
     :return: User
     """
     try:
-      user = self.session.execute(
+      with Session(self.engine) as session:
-        select(Model).where(Model.name == name, Model.application_id == application_id)
+        user = session.execute(
-      ).first()
+          select(Model).where(Model.name == name, Model.application_id == application_id)
-      if user:
+        ).first()
-        if Auth.check_password(password, user[0].password):
+        if user:
-          return user[0]
+          if Auth.check_password(password, user[0].password):
+            return user[0]
     except SQLAlchemyError as err:
       logging.error('Error while fetching user by name: %s', err)
       raise SQLAlchemyError from err
@@ -140,10 +147,11 @@ class User(Repository):
     :return: User
     """
     try:
-      application = self.session.execute(
+      with Session(self.engine) as session:
-        select(ApplicationModel).where(ApplicationModel.application_uuid == application_uuid)
+        application = session.execute(
-      ).first()
+          select(ApplicationModel).where(ApplicationModel.application_uuid == application_uuid)
-      return self.get_by_name_application_id_and_password(name, password, application[0].id)
+        ).first()
+        return self.get_by_name_application_id_and_password(name, password, application[0].id)
     except SQLAlchemyError as err:
       logging.error('Error while fetching user by name: %s', err)
       raise SQLAlchemyError from err

hub/persistence/repository.py

@@ -6,7 +6,6 @@ Project Coder Peter Yefi peteryefi@gmail.com
 """
 import logging
 from sqlalchemy import create_engine
-from sqlalchemy.orm import Session
 from hub.persistence.configuration import Configuration
 
 
@@ -19,6 +18,5 @@ class Repository:
     try:
       self.configuration = Configuration(db_name, dotenv_path, app_env)
       self.engine = create_engine(self.configuration.connection_string)
-      self.session = Session(self.engine)
     except ValueError as err:
       logging.error('Missing value for credentials: %s', err)

tests/test_db_factory.py

@@ -103,16 +103,16 @@ class Control:
       app_env='TEST',
       dotenv_path=dotenv_path)
 
-    self._application_uuid = '60b7fc1b-f389-4254-9ffd-22a4cf32c7a3'
+    self._application_uuid = 'b9e0ce80-1218-410c-8a64-9d9b7026aad8'
     self._application_id = 1
     self._user_id = 1
 
     self._application_id = self._database.persist_application(
-      'City_layers',
+      'test',
-      'City layers test user',
+      'test',
       self.application_uuid
     )
-    self._user_id = self._database.create_user('city_layers', self._application_id, 'city_layers', UserRoles.Admin)
+    self._user_id = self._database.create_user('test', self._application_id, 'test', UserRoles.Admin)
 
     self._pickle_path = Path('tests_data/pickle_path.bz2').resolve()