Partial follow Pylint recommendation

hub/imports/geometry_factory.py

@@ -4,9 +4,9 @@ SPDX - License - Identifier: LGPL - 3.0 - or -later
 Copyright © 2022 Concordia CERC group
 Project Coder Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
 """
-
-import geopandas
 import logging
+import geopandas
+
 from hub.city_model_structure.city import City
 from hub.imports.geometry.citygml import CityGml
 from hub.imports.geometry.obj import Obj

hub/imports/weather_factory.py

@@ -52,7 +52,3 @@ class WeatherFactory:
     :return: None
     """
     getattr(self, self._handler, lambda: None)()
-
-  def enrich_debug(self):
-    _path = Path(self._base_path / 'epw').resolve()
-    return EpwWeatherParameters(self._city, _path, self._file_name)

hub/persistence/__init__.py

@@ -1,3 +1,7 @@
+"""
+Persistence package
+"""
+
 from .repository import Repository
 from .repositories.city import City
 from .repositories.application import Application

hub/persistence/configuration.py

@@ -28,8 +28,9 @@ class Configuration:
     try:
       # load environmental variables
       if not Path(dotenv_path).exists():
-        logging.error(f'dotenv file doesn\'t exists at {dotenv_path}')
+        error_message = f'dotenv file doesn\'t exists at {dotenv_path}'
-        raise FileNotFoundError(f'dotenv file doesn\'t exists at {dotenv_path}')
+        logging.error(error_message)
+        raise FileNotFoundError(error_message)
       load_dotenv(dotenv_path=dotenv_path)
 
       self._db_name = db_name
@@ -39,7 +40,7 @@ class Configuration:
       self._db_port = os.getenv(f'{app_env}_DB_PORT')
       self.hub_token = os.getenv('HUB_TOKEN')
     except KeyError as err:
-      logging.error(f'Error with credentials: {err}')
+      logging.error('Error with credentials: %s', err)
 
   @property
   def connection_string(self):

hub/persistence/db_setup.py

@@ -5,6 +5,7 @@ Copyright © 2022 Concordia CERC group
 Project Coder Peter Yefi peteryefi@gmail.com
 """
 
+import logging
 from hub.persistence import Repository
 from hub.persistence.models import Application
 from hub.persistence.models import City
@@ -14,17 +15,21 @@ from hub.persistence.models import UserRoles
 from hub.persistence.models import SimulationResults
 from hub.persistence.repositories import User as UserRepository
 from hub.persistence.repositories import Application as ApplicationRepository
-import logging
 
 
 class DBSetup:
+  """
+  Creates a Persistence database structure
+  """
 
   def __init__(self, db_name, app_env, dotenv_path, admin_password, application_uuid):
     """
     Creates database tables a default admin user and a default admin app with the given password and uuid
-    :param db_name:
+    :param db_name: database name
-    :param app_env:
+    :param app_env: application environment type [TEST|PROD]
-    :param dotenv_path:
+    :param dotenv_path: .env file path
+    :param admin_password: administrator password for the application uuid
+    :application_uuid: application uuid
     """
     repository = Repository(db_name=db_name, app_env=app_env, dotenv_path=dotenv_path)
 
@@ -47,7 +52,7 @@ class DBSetup:
     logging.info('Creating default admin tool application...')
     application = application_repo.insert(name, description, application_uuid)
 
-    if type(application) is dict:
+    if isinstance(application, dict):
       logging.info(application)
     else:
       msg = f'Created Admin tool with application_uuid: {application_uuid}'
@@ -59,7 +64,7 @@ class DBSetup:
     password = admin_password
     logging.info('Creating default admin user...')
     user = user_repo.insert('Administrator', password, UserRoles.Admin, application_id)
-    if type(user) is dict:
+    if isinstance(user, dict):
       logging.info(user)
     else:
-      logging.info(f'Created Admin user')
+      logging.info('Created Admin user')

hub/persistence/models/__init__.py

@@ -1,3 +1,6 @@
+"""
+Models package
+"""
 from .application import Application
 from .city import City
 from .city_object import CityObject

hub/persistence/models/user.py

@@ -15,6 +15,9 @@ from hub.persistence.configuration import Models
 
 
 class UserRoles(enum.Enum):
+  """
+  User roles enum
+  """
   Admin = 'Admin'
   Hub_Reader = 'Hub_Reader'
 

hub/persistence/repositories/__init__.py

@@ -1,2 +1,5 @@
+"""
+Repositories Package
+"""
 from .user import User
 from .application import Application

hub/persistence/repositories/application.py

@@ -16,6 +16,9 @@ from hub.persistence.models import Application as Model
 
 
 class Application(Repository):
+  """
+  Application repository
+  """
   _instance = None
 
   def __init__(self, db_name: str, dotenv_path: str, app_env: str):
@@ -46,9 +49,8 @@ class Application(Repository):
         self.session.commit()
         return application
       except SQLAlchemyError as err:
-        logging.error(f'An error occurred while creating application: {err}')
+        logging.error('An error occurred while creating application: %s', err)
-    else:
+    return {'message': f'An error occurred while creating application {application_uuid}'}
-      return {'message': f'An application with {application_uuid} application uuid, already exists'}
 
   def update(self, application_uuid: str, name: str, description: str) -> Union[Dict, None]:
     """
@@ -64,8 +66,9 @@ class Application(Repository):
       ).update({'name': name, 'description': description, 'updated': datetime.datetime.utcnow()})
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while updating application: {err}')
+      logging.error('Error while updating application %s', err)
       return {'message': 'Error occurred while updating application'}
+    return None
 
   def delete(self, application_uuid: str):
     """
@@ -78,7 +81,7 @@ class Application(Repository):
       self.session.flush()
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while deleting application: {err}')
+      logging.error('Error while deleting application: %s', err)
 
   def get_by_uuid(self, application_uuid: str) -> Union[Model, None]:
     """
@@ -86,12 +89,13 @@ class Application(Repository):
     :param application_uuid: the application uuid
     :return: Application with the provided application_uuid or None
     """
+    result_set = None
     try:
       result_set = self.session.execute(select(Model).where(
         Model.application_uuid == application_uuid)
       ).first()
+    except SQLAlchemyError as err:
+      logging.error('Error while fetching application by application_uuid: %s',  err)
     if result_set is None:
       return None
     return result_set[0]
-    except SQLAlchemyError as err:
-      logging.error(f'Error while fetching application by application_uuid: {err}')

hub/persistence/repositories/city.py

@@ -6,7 +6,7 @@ Project Coder Peter Yefi peteryefi@gmail.com
 """
 import logging
 import datetime
-from typing import Union, Dict
+from typing import Union
 
 from sqlalchemy import select
 from sqlalchemy.exc import SQLAlchemyError
@@ -19,6 +19,9 @@ from hub.version import __version__
 
 
 class City(Repository):
+  """
+  City repository
+  """
   _instance = None
 
   def __init__(self, db_name: str, dotenv_path: str, app_env: str):
@@ -32,14 +35,14 @@ class City(Repository):
       cls._instance = super(City, cls).__new__(cls)
     return cls._instance
 
-  def insert(self, city: CityHub, pickle_path, application_id, user_id: int) -> Union[Model, Dict]:
+  def insert(self, city: CityHub, pickle_path, application_id, user_id: int) -> Union[Model, None]:
     """
     Inserts a city
     :param city: The complete city instance
     :param pickle_path: Path to the pickle
     :param application_id: Application id owning the instance
     :param user_id: User id owning the instance
-    :return: City and Dictionary
+    :return: City and None
     """
     city.save_compressed(pickle_path)
     try:
@@ -63,7 +66,8 @@ class City(Repository):
       self.session.commit()
       return db_city
     except SQLAlchemyError as err:
-      logging.error(f'An error occurred while creating city: {err}')
+      logging.error('An error occurred while creating city: %s', err)
+    return None
 
   def update(self, city_id: int, city: CityHub):
     """
@@ -74,11 +78,10 @@ class City(Repository):
     """
     try:
       now = datetime.datetime.utcnow()
-      print(f'{now}')
       self.session.query(Model).filter(Model.id == city_id).update({'name': city.name, 'updated': now})
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while updating city: {err}')
+      logging.error('Error while updating city: %s', err)
 
   def delete(self, city_id: int):
     """
@@ -91,7 +94,7 @@ class City(Repository):
       self.session.query(Model).filter(Model.id == city_id).delete()
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching city: {err}')
+      logging.error('Error while fetching city: %s', err)
 
   def get_by_user_id_application_id_and_name(self, user_id, application_id, city_name):
     """
@@ -110,7 +113,8 @@ class City(Repository):
         result_set = result_set[0]
       return result_set
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching city by name: {err}')
+      logging.error('Error while fetching city by name: %s', err)
+    return None
 
   def get_by_user_id_and_application_id(self, user_id, application_id) -> [Model]:
     """
@@ -125,4 +129,5 @@ class City(Repository):
       )
       return [r[0] for r in result_set]
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching city by name: {err}')
+      logging.error('Error while fetching city by name: %s', err)
+    return None

hub/persistence/repositories/city_object.py

@@ -45,11 +45,12 @@ class CityObject(Repository):
         self.session.add(city_object)
         self.session.flush()
         self.session.commit()
-        return city_object
+
       except SQLAlchemyError as err:
-        logging.error(f'An error occurred while creating city_object: {err}')
+        logging.error('An error occurred while creating city_object: %s', err)
     else:
       return {'message': f'A city_object named {building.name} already exists in that city'}
+    return city_object
 
   def update(self, city_id: int, building: Building) -> Union[Dict, None]:
     """
@@ -76,8 +77,9 @@ class CityObject(Repository):
          'updated': datetime.datetime.utcnow()})
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while updating city object: {err}')
+      logging.error('Error while updating city object: %s', err)
       return {'message': 'Error occurred while updating application'}
+    return None
 
   def delete(self, city_id: int, name: str):
     """
@@ -90,7 +92,7 @@ class CityObject(Repository):
       self.session.query(Model).filter(Model.city_id == city_id, Model.name == name).delete()
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while deleting application: {err}')
+      logging.error('Error while deleting application: %s', err)
 
   def get_by_name_and_city(self, name, city_id) -> Union[Model, None]:
     """
@@ -99,13 +101,13 @@ class CityObject(Repository):
     :param city_id: a city identifier
     :return: [CityObject] with the provided name belonging to the city with id city_id
     """
+    _city_object = None
     try:
       _city_object = self.session.execute(select(Model).where(
         Model.name == name, Model.city_id == city_id
       )).first()
+    except SQLAlchemyError as err:
+      logging.error('Error while fetching application by application_uuid: %s', err)
     if _city_object is None:
       return None
     return _city_object[0]
-    except SQLAlchemyError as err:
-      print(err)
-      logging.error(f'Error while fetching application by application_uuid: {err}')

hub/persistence/repositories/simulation_results.py

@@ -19,6 +19,9 @@ from hub.persistence.models import SimulationResults as Model
 
 
 class SimulationResults(Repository):
+  """
+  Simulation results repository
+  """
   _instance = None
 
   def __init__(self, db_name: str, dotenv_path: str, app_env: str):
@@ -44,11 +47,11 @@ class SimulationResults(Repository):
     if city_id is not None:
       city = self._get_city(city_id)
       if city is None:
-        return {'message': f'City does not exists'}
+        return {'message': 'City does not exists'}
     else:
       city_object = self._get_city_object(city_object_id)
       if city_object is None:
-        return {'message': f'City object does not exists'}
+        return {'message': 'City object does not exists'}
     try:
       simulation_result = Model(name=name,
                                 values=values,
@@ -59,7 +62,9 @@ class SimulationResults(Repository):
       self.session.commit()
       return simulation_result
     except SQLAlchemyError as err:
-      logging.error(f'An error occurred while creating city_object: {err}')
+      error_message = f'An error occurred while creating city_object: {err}'
+      logging.error(error_message)
+      return {'message': error_message}
 
   def update(self, name: str, values: str, city_id=None, city_object_id=None) -> Union[Dict, None]:
     """
@@ -88,17 +93,19 @@ class SimulationResults(Repository):
       else:
         return {'message': 'Missing either city_id or city_object_id'}
     except SQLAlchemyError as err:
-      logging.error(f'Error while updating city object: {err}')
+      error_message = f'Error while updating city object: {err}'
-      return {'message': 'Error occurred while updating application'}
+      logging.error(error_message)
+      return {'message': error_message}
+    return None
 
-  def delete(self, name: str, city_id=None, city_object_id=None):
+  def delete(self, name: str, city_id=None, city_object_id=None) -> Union[Dict, None]:
     """
     Deletes an application with the application_uuid
     :param name: The simulation results tool and workflow name
     :param city_id: The id for the city owning the simulation results
     :param city_object_id: the id for the city_object owning these simulation results
 
-    :return: None
+    :return: [Dict, None]
     """
     try:
       if city_id is not None:
@@ -110,9 +117,10 @@ class SimulationResults(Repository):
       else:
         return {'message': 'Missing either city_id or city_object_id'}
     except SQLAlchemyError as err:
-      logging.error(f'Error while deleting application: {err}')
+      logging.error('Error while deleting application: %s', err)
+    return None
 
-  def _get_city(self, city_id) -> [City]:
+  def _get_city(self, city_id) -> [City, None]:
     """
     Fetch a city object based city id
     :param city_id: a city identifier
@@ -121,7 +129,8 @@ class SimulationResults(Repository):
     try:
       return self.session.execute(select(City).where(City.id == city_id)).first()
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching city by city_id: {err}')
+      logging.error('Error while fetching city by city_id: %s', err)
+    return None
 
   def _get_city_object(self, city_object_id) -> [CityObject]:
     """
@@ -132,7 +141,8 @@ class SimulationResults(Repository):
     try:
       return self.session.execute(select(CityObject).where(CityObject.id == city_object_id)).first()
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching city by city_id: {err}')
+      logging.error('Error while fetching city by city_id: %s', err)
+    return None
 
   def get_simulation_results_by_city_id_city_object_id_and_names(self, city_id, city_object_id, result_names=None):
     """
@@ -156,4 +166,5 @@ class SimulationResults(Repository):
           _.append(result)
       return _
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching city by city_id: {err}')
+      logging.error('Error while fetching city by city_id: %s', err)
+    return None

hub/persistence/repositories/user.py

@@ -5,18 +5,20 @@ Copyright © 2022 Concordia CERC group
 Project Coder Peter Yefi peteryefi@gmail.com
 """
 import logging
-from hub.persistence import Repository
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy import select
-from hub.persistence.models import User as Model
-from hub.persistence.models import Application as ApplicationModel
-from hub.persistence.models import UserRoles
-from hub.helpers.auth import Auth
 from typing import Union, Dict
 import datetime
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy import select
+from hub.persistence import Repository
+from hub.persistence.models import User as Model, Application as ApplicationModel, UserRoles
+from hub.helpers.auth import Auth
+
 
 
 class User(Repository):
+  """
+  User class
+  """
   _instance = None
 
   def __init__(self, db_name: str, dotenv_path: str, app_env: str):
@@ -48,9 +50,9 @@ class User(Repository):
         self.session.commit()
         return user
       except SQLAlchemyError as err:
-        logging.error(f'An error occurred while creating user: {err}')
+        error_message = f'An error occurred while creating user: {err}'
-    else:
+        logging.error(error_message)
-      return {'message': f'user {name} already exists for that application'}
+    return {'message': f'error creating user {name}'}
 
   def update(self, user_id: int, name: str, password: str, role: UserRoles) -> Union[Dict, None]:
     """
@@ -70,8 +72,9 @@ class User(Repository):
       })
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while updating user: {err}')
+      logging.error('Error while updating user: %s', err)
       return {'err_msg': 'Error occurred while updated user'}
+    return None
 
   def delete(self, user_id: int):
     """
@@ -83,7 +86,7 @@ class User(Repository):
       self.session.query(Model).filter(Model.id == user_id).delete()
       self.session.commit()
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching user: {err}')
+      logging.error('Error while fetching user: %s', err)
 
   def get_by_name_and_application(self, name: str, application_id: int) -> Union[Model, None]:
     """
@@ -92,15 +95,16 @@ class User(Repository):
     :param application_id: User application name
     :return: User matching the search criteria or None
     """
+    user = None
     try:
       user = self.session.execute(
         select(Model).where(Model.name == name, Model.application_id == application_id)
       ).first()
       if user is not None:
         user = user[0]
-      return user
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching user by name and application: {err}')
+      logging.error('Error while fetching user by name and application: %s', err)
+    return user
 
   def get_by_name_application_id_and_password(self, name: str, password: str, application_id: int) -> Union[Model, None]:
     """
@@ -118,7 +122,8 @@ class User(Repository):
         if Auth.check_password(password, user[0].password):
           return user[0]
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching user by email: {err}')
+      logging.error('Error while fetching user by email: %s', err)
+    return None
 
   def get_by_name_application_uuid_and_password(self, name: str, password: str, application_uuid: str) -> Union[Model, None]:
     """
@@ -128,10 +133,11 @@ class User(Repository):
     :param application_uuid: Application uuid
     :return: User
     """
+    application = None
     try:
       application = self.session.execute(
         select(ApplicationModel).where(ApplicationModel.application_uuid == application_uuid)
       ).first()
-      return self.get_by_name_application_id_and_password(name, password, application[0].id)
     except SQLAlchemyError as err:
-      logging.error(f'Error while fetching user by name: {err}')
+      logging.error('Error while fetching user by name: %s', err)
+    return self.get_by_name_application_id_and_password(name, password, application[0].id)

hub/persistence/repository.py

@@ -5,13 +5,16 @@ Copyright © 2022 Concordia CERC group
 Project Coder Peter Yefi peteryefi@gmail.com
 """
 import logging
-
-from hub.persistence.configuration import Configuration
 from sqlalchemy import create_engine
 from sqlalchemy.orm import Session
+from hub.persistence.configuration import Configuration
+
 
 
 class Repository:
+  """
+  Base repository class to establish db connection
+  """
 
   def __init__(self, db_name, dotenv_path: str, app_env='TEST'):
     try:
@@ -19,4 +22,4 @@ class Repository:
       self.engine = create_engine(self.configuration.connection_string)
       self.session = Session(self.engine)
     except ValueError as err:
-      logging.error(f'Missing value for credentials: {err}')
+      logging.error('Missing value for credentials: %s', err)

hub/version.py

@@ -1 +1,4 @@
+"""
+Hub version number
+"""
 __version__ = '0.1.7.12'