Correct cerc_persistence autodocumentation

cerc_persistence/configuration.py

@@ -20,11 +20,6 @@ class Configuration:
   """
 
   def __init__(self, db_name: str, dotenv_path: str, app_env='TEST'):
-    """
-    :param db_name: database name
-    :param app_env: application environment, test or production
-    :param dotenv_path: the absolute path to dotenv file
-    """
     try:
       # load environmental variables
       if not Path(dotenv_path).exists():

cerc_persistence/db_control.py

@@ -148,27 +148,27 @@ class DBControl:
 
   def update_city(self, city_id, city):
     """
-   Update an existing city in the database
+    Update an existing city in the database
-   :param city_id: the id of the city to update
+    :param city_id: the id of the city to update
-   :param city: the updated city object
+    :param city: the updated city object
     """
     return self._city.update(city_id, city)
 
   def persist_application(self, name: str, description: str, application_uuid: str):
     """
     Creates information for an application in the database
-   :param name: name of application
+    :param name: name of application
-   :param description: the description of the application
+    :param description: the description of the application
-   :param application_uuid: the uuid of the application to be created
+    :param application_uuid: the uuid of the application to be created
     """
     return self._application.insert(name, description, application_uuid)
 
   def update_application(self, name: str, description: str, application_uuid: str):
     """
     Update the application information stored in the database
-   :param name: name of application
+    :param name: name of application
-   :param description: the description of the application
+    :param description: the description of the application
-   :param application_uuid: the uuid of the application to be created
+    :param application_uuid: the uuid of the application to be created
     """
     return self._application.update(application_uuid, name, description)
 
@@ -236,6 +236,13 @@ class DBControl:
   def delete_application(self, application_uuid):
     """
     Deletes a single application from the database
-    :param application_uuid: the id of the application to get
+    :param application_uuid: the id of the application to delete
     """
     self._application.delete(application_uuid)
+
+  def get_city(self, city_id):
+    """
+    Get a single city by id
+    :param city_id: the id of the city to get
+    """
+    return self._city.get_by_id(city_id)

cerc_persistence/db_setup.py

@@ -23,14 +23,6 @@ class DBSetup:
   """
 
   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: database name
-    :param app_env: application environment type [TEST|PROD]
-    :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)
 
     # Create the tables using the models

cerc_persistence/models/application.py

@@ -16,7 +16,7 @@ from cerc_persistence.configuration import Models
 
 class Application(Models):
   """
-  A model representation of an application
+  Application(Models) class
   """
   __tablename__ = 'application'
   id = Column(Integer, Sequence('application_id_seq'), primary_key=True)

cerc_persistence/models/city.py

@@ -14,7 +14,8 @@ from cerc_persistence.configuration import Models
 
 
 class City(Models):
-  """A model representation of a city
+  """
+  City(Models) class
   """
   __tablename__ = 'city'
   id = Column(Integer, Sequence('city_id_seq'), primary_key=True)

cerc_persistence/models/city_object.py

@@ -17,7 +17,7 @@ from cerc_persistence.configuration import Models
 
 class CityObject(Models):
   """
-  A model representation of an application
+  CityObject(Models) class
   """
   __tablename__ = 'city_object'
   id = Column(Integer, Sequence('city_object_id_seq'), primary_key=True)

cerc_persistence/models/simulation_results.py

@@ -15,7 +15,7 @@ from cerc_persistence.configuration import Models
 
 class SimulationResults(Models):
   """
-  A model representation of an application
+  SimulationResults(Models) class
   """
   __tablename__ = 'simulation_results'
   id = Column(Integer, Sequence('simulation_results_id_seq'), primary_key=True)

cerc_persistence/models/user.py

@@ -24,7 +24,7 @@ class UserRoles(enum.Enum):
 
 class User(Models):
   """
-  A model representation of a city
+  User(Models) class
   """
   __tablename__ = 'user'
   id = Column(Integer, Sequence('user_id_seq'), primary_key=True)

cerc_persistence/repositories/application.py

@@ -18,7 +18,7 @@ from cerc_persistence.models import Application as Model
 
 class Application(Repository):
   """
-  Application repository
+  Application(Repository) class
   """
   _instance = None
 
@@ -26,9 +26,6 @@ class Application(Repository):
     super().__init__(db_name, dotenv_path, app_env)
 
   def __new__(cls, db_name, dotenv_path, app_env):
-    """
-    Implemented for a singleton pattern
-    """
     if cls._instance is None:
       cls._instance = super(Application, cls).__new__(cls)
     return cls._instance

cerc_persistence/repositories/city.py

@@ -20,7 +20,7 @@ from cerc_persistence.models import CityObject
 
 class City(Repository):
   """
-  City repository
+  City(Repository) class
   """
   _instance = None
 
@@ -28,9 +28,6 @@ class City(Repository):
     super().__init__(db_name, dotenv_path, app_env)
 
   def __new__(cls, db_name, dotenv_path, app_env):
-    """
-    Implemented for a singleton pattern
-    """
     if cls._instance is None:
       cls._instance = super(City, cls).__new__(cls)
     return cls._instance
@@ -136,3 +133,7 @@ class City(Repository):
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by name %s', err)
       raise SQLAlchemyError from err
+
+  def get_by_id(self, city_id) -> Model:
+    with Session(self.engine) as session:
+      return session.execute(select(Model).where(Model.id == city_id)).first()[0]

cerc_persistence/repositories/city_object.py

@@ -19,7 +19,7 @@ from cerc_persistence.repository import Repository
 
 class CityObject(Repository):
   """
-  City object repository
+  CityObject(Repository) class
   """
   _instance = None
 
@@ -27,9 +27,6 @@ class CityObject(Repository):
     super().__init__(db_name, dotenv_path, app_env)
 
   def __new__(cls, db_name, dotenv_path, app_env):
-    """
-    Implemented for a singleton pattern
-    """
     if cls._instance is None:
       cls._instance = super(CityObject, cls).__new__(cls)
     return cls._instance

cerc_persistence/repositories/simulation_results.py

@@ -20,7 +20,7 @@ from cerc_persistence.models import SimulationResults as Model
 
 class SimulationResults(Repository):
   """
-  Simulation results repository
+  SimulationResults(Repository) class
   """
   _instance = None
 
@@ -28,9 +28,6 @@ class SimulationResults(Repository):
     super().__init__(db_name, dotenv_path, app_env)
 
   def __new__(cls, db_name, dotenv_path, app_env):
-    """
-    Implemented for a singleton pattern
-    """
     if cls._instance is None:
       cls._instance = super(SimulationResults, cls).__new__(cls)
     return cls._instance

cerc_persistence/repositories/user.py

@@ -18,7 +18,7 @@ from cerc_persistence.models import User as Model, Application as ApplicationMod
 
 class User(Repository):
   """
-  User class
+  User(Repository) class
   """
   _instance = None
 
@@ -26,9 +26,6 @@ class User(Repository):
     super().__init__(db_name, dotenv_path, app_env)
 
   def __new__(cls, db_name, dotenv_path, app_env):
-    """
-    Implemented for a singleton pattern
-    """
     if cls._instance is None:
       cls._instance = super(User, cls).__new__(cls)
     return cls._instance

cerc_persistence/version.py

@@ -1,4 +1,4 @@
 """
 CERC Persistence version number
 """
-__version__ = '1.0.0.0'
+__version__ = '1.0.0.2'

setup.py

@@ -20,8 +20,13 @@ with open(version) as f:
 setup(
   name='cerc-persistence',
   version=main_ns['__version__'],
-  description="",
+  description="CERC Persistence consist of a set of classes to store and retrieve Cerc Hub cities and results",
-  long_description="",
+  long_description="CERC Persistence consist of a set of classes to store and retrieve Cerc Hub cities and results.\n\n"
+                   "Developed at Concordia university in Canada as part of the research group from the Next Generation "
+                   "Cities Institute, our aim among others is to provide a comprehensive set of tools to help "
+                   "researchers and urban developers to make decisions to improve the livability and efficiency of our "
+                   "cities, cerc persistence will store the simulation results and city information to make those "
+                   "available for other researchers.",
   classifiers=[
     "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",
     "Programming Language :: Python",

unittests/test_db_retrieve.py

@@ -5,18 +5,9 @@ Copyright © 2022 Concordia CERC group
 Project Coder Ruben Sanchez ruben.sanchez@mail.concordia.ca
 """
 import datetime
-import distutils.spawn
-import os
 import unittest
-from pathlib import Path
 from unittest import TestCase
 
-from sqlalchemy import create_engine
-from sqlalchemy_utils import database_exists, create_database, drop_database
-
-from cerc_persistence.db_control import DBControl
-from cerc_persistence.repository import Repository
-from cerc_persistence.models import City, Application, CityObject, SimulationResults, User
 from unittests.control import Control
 
 control = Control()