formatting and cleanup

Author: devsetgo

coverage.xml

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 
-__version__ = '0.13.3'
+__version__ = "0.13.3"

dsg_lib/__init__.py

@@ -1,4 +1,29 @@
 # -*- coding: utf-8 -*-
+"""
+This module provides functionality to import and validate SQLAlchemy components, ensuring compatibility with the required version.
+
+The `import_sqlalchemy` function is the primary function in this module. It imports various components from SQLAlchemy, checks the version of SQLAlchemy, and raises an ImportError if the version is below the minimum required version.
+
+Usage example:
+    ```python
+    from import_sqlalchemy import import_sqlalchemy
+
+    sqlalchemy_components = import_sqlalchemy()
+    sqlalchemy, MetaData, create_engine, text, Column, DateTime, String, IntegrityError, SQLAlchemyError, AsyncSession = sqlalchemy_components
+
+    # Example usage of imported components
+    engine = create_engine('sqlite:///example.db')
+    metadata = MetaData()
+    ```
+
+Author(s):
+    Mike Ryan
+
+Date Created:
+    2024/05/16
+Date Updated:
+    2024/07/26
+"""
 from typing import Tuple
 
 from loguru import logger
@@ -15,7 +40,7 @@ def import_sqlalchemy() -> Tuple:
     and raises an ImportError if the version is less than the minimum required version.
 
     Returns:
-        tuple: A tuple containing the following SQLAlchemy components:
+        Tuple: A tuple containing the following SQLAlchemy components:
             - sqlalchemy: The SQLAlchemy module.
             - MetaData: The MetaData class from SQLAlchemy.
             - create_engine: The create_engine function from SQLAlchemy.
@@ -26,23 +51,25 @@ def import_sqlalchemy() -> Tuple:
             - IntegrityError: The IntegrityError exception from SQLAlchemy.
             - SQLAlchemyError: The SQLAlchemyError exception from SQLAlchemy.
             - AsyncSession: The AsyncSession class from SQLAlchemy.
-            - create_async_engine: The create_async_engine function from SQLAlchemy.
-            - select: The select function from SQLAlchemy.
-            - declarative_base: The declarative_base function from SQLAlchemy.
-            - sessionmaker: The sessionmaker function from SQLAlchemy.
-            - func: The func object from SQLAlchemy.
-            - NoResultFound: The NoResultFound exception from SQLAlchemy.
 
     Raises:
-        ImportError: If the SQLAlchemy version is less than the minimum required version.
+        ImportError: If SQLAlchemy is not installed or the version is below the minimum required version.
+
+    Example:
+        ```python
+        from import_sqlalchemy import import_sqlalchemy
+
+        sqlalchemy_components = import_sqlalchemy()
+        sqlalchemy, MetaData, create_engine, text, Column, DateTime, String, IntegrityError, SQLAlchemyError, AsyncSession = sqlalchemy_components
 
-    Author: Mike Ryan
-    Date: 2024/05/16
-    License: MIT
+        # Example usage of imported components
+        engine = create_engine('sqlite:///example.db')
+        metadata = MetaData()
+        ```
     """
-    min_version = '2.0.0'  # Minimum required version of SQLAlchemy
+    min_version = "2.0.0"  # Minimum required version of SQLAlchemy
 
-    logger.info('Attempting to import SQLAlchemy...')
+    logger.info("Attempting to import SQLAlchemy...")
 
     try:
         # Import SQLAlchemy and its components
@@ -55,11 +82,11 @@ def import_sqlalchemy() -> Tuple:
         from sqlalchemy.orm.exc import NoResultFound
         from sqlalchemy.sql import func
 
-        logger.info('Successfully imported SQLAlchemy.')
+        logger.info("Successfully imported SQLAlchemy.")
 
     except ImportError:  # pragma: no cover
         # Handle the case where SQLAlchemy is not installed
-        logger.error('Failed to import SQLAlchemy.')
+        logger.error("Failed to import SQLAlchemy.")
         create_engine = text = sqlalchemy = None  # pragma: no cover
 
     # Check SQLAlchemy version
@@ -68,13 +95,13 @@ def import_sqlalchemy() -> Tuple:
     ) < packaging_version.parse(min_version):
         # If the installed version is less than the minimum required version, raise an error
         logger.error(
-            f'SQLAlchemy version >= {min_version} required, run `pip install --upgrade sqlalchemy`'
+            f"SQLAlchemy version >= {min_version} required, run `pip install --upgrade sqlalchemy`"
         )
         raise ImportError(
-            f'SQLAlchemy version >= {min_version} required, run `pip install --upgrade sqlalchemy`'
+            f"SQLAlchemy version >= {min_version} required, run `pip install --upgrade sqlalchemy`"
         )  # pragma: no cover
 
-    logger.info('Returning SQLAlchemy components.')
+    logger.info("Returning SQLAlchemy components.")
 
     # Return the imported SQLAlchemy components
     return (
@@ -118,4 +145,6 @@ def import_sqlalchemy() -> Tuple:
     String,  # The String class from SQLAlchemy
     func,  # The func object from SQLAlchemy
     NoResultFound,  # The NoResultFound exception from SQLAlchemy
-) = import_sqlalchemy()  # Call the function that imports SQLAlchemy and checks its version
+) = (
+    import_sqlalchemy()
+)  # Call the function that imports SQLAlchemy and checks its version

dsg_lib/async_database_functions/__import_sqlalchemy.py

@@ -85,7 +85,7 @@ def __init__(self, db_config: DBConfig):
         """
         self.db_config = db_config
         self.Base = BASE
-        logger.debug('AsyncDatabase initialized')
+        logger.debug("AsyncDatabase initialized")
 
     def get_db_session(self):
         """This method returns a context manager that provides a new database
@@ -96,7 +96,7 @@ def get_db_session(self):
         Returns: contextlib._GeneratorContextManager: A context manager that
         provides a new database session.
         """
-        logger.debug('Getting database session')
+        logger.debug("Getting database session")
         return self.db_config.get_db_session()
 
     async def create_tables(self):
@@ -106,7 +106,7 @@ async def create_tables(self):
 
         Returns: None
         """
-        logger.debug('Creating tables')
+        logger.debug("Creating tables")
         try:
             # Bind the engine to the metadata of the base class
             self.Base.metadata.bind = self.db_config.engine
@@ -115,8 +115,8 @@ async def create_tables(self):
             async with self.db_config.engine.begin() as conn:
                 # Run a function in a synchronous manner
                 await conn.run_sync(self.Base.metadata.create_all)
-            logger.info('Tables created successfully')
+            logger.info("Tables created successfully")
         except Exception as ex:  # pragma: no cover
             # Log the error and raise it
-            logger.error(f'Error creating tables: {ex}')  # pragma: no cover
+            logger.error(f"Error creating tables: {ex}")  # pragma: no cover
             raise  # pragma: no cover

dsg_lib/async_database_functions/async_database.py

@@ -56,14 +56,18 @@ class MyModel(base_schema.SchemaBaseSQLite):
     String,  # The String class from SQLAlchemy
     func,  # The func object from SQLAlchemy
     NoResultFound,  # The NoResultFound exception from SQLAlchemy
-) = import_sqlalchemy()  # Call the function that imports SQLAlchemy and checks its version
+) = (
+    import_sqlalchemy()
+)  # Call the function that imports SQLAlchemy and checks its version
 
 
 # comments
-uuid_comment = 'Unique identifier for each record, a string representation of a UUID'
-date_created_comment = 'Date and time when a row was inserted, defaults to current UTC time'
+uuid_comment = "Unique identifier for each record, a string representation of a UUID"
+date_created_comment = (
+    "Date and time when a row was inserted, defaults to current UTC time"
+)
 date_updated_comment = (
-    'Date and time when a row was last updated, defaults to current UTC time on update'
+    "Date and time when a row was last updated, defaults to current UTC time on update"
 )
 
 
@@ -228,7 +232,7 @@ class MyModel(base_schema.SchemaBaseMySQL, BASE):
     date_created = Column(
         DateTime,
         index=True,
-        server_default=text('UTC_TIMESTAMP()'),
+        server_default=text("UTC_TIMESTAMP()"),
         comment=date_created_comment,
     )
 
@@ -237,8 +241,8 @@ class MyModel(base_schema.SchemaBaseMySQL, BASE):
     date_updated = Column(
         DateTime,
         index=True,
-        server_default=text('UTC_TIMESTAMP()'),
-        onupdate=text('UTC_TIMESTAMP()'),
+        server_default=text("UTC_TIMESTAMP()"),
+        onupdate=text("UTC_TIMESTAMP()"),
         comment=date_updated_comment,
     )
 
@@ -287,7 +291,7 @@ class MyModel(base_schema.SchemaBaseOracle, BASE):
     date_created = Column(
         DateTime,
         index=True,
-        server_default=text('SYS_EXTRACT_UTC(SYSTIMESTAMP)'),
+        server_default=text("SYS_EXTRACT_UTC(SYSTIMESTAMP)"),
         comment=date_created_comment,
     )
 
@@ -296,8 +300,8 @@ class MyModel(base_schema.SchemaBaseOracle, BASE):
     date_updated = Column(
         DateTime,
         index=True,
-        server_default=text('SYS_EXTRACT_UTC(SYSTIMESTAMP)'),
-        onupdate=text('SYS_EXTRACT_UTC(SYSTIMESTAMP)'),
+        server_default=text("SYS_EXTRACT_UTC(SYSTIMESTAMP)"),
+        onupdate=text("SYS_EXTRACT_UTC(SYSTIMESTAMP)"),
         comment=date_updated_comment,
     )
 
@@ -346,7 +350,7 @@ class MyModel(base_schema.SchemaBaseMSSQL, BASE):
     date_created = Column(
         DateTime,
         index=True,
-        server_default=text('GETUTCDATE()'),
+        server_default=text("GETUTCDATE()"),
         comment=date_created_comment,
     )
 
@@ -355,8 +359,8 @@ class MyModel(base_schema.SchemaBaseMSSQL, BASE):
     date_updated = Column(
         DateTime,
         index=True,
-        server_default=text('GETUTCDATE()'),
-        onupdate=text('GETUTCDATE()'),
+        server_default=text("GETUTCDATE()"),
+        onupdate=text("GETUTCDATE()"),
         comment=date_updated_comment,
     )
 
@@ -405,18 +409,18 @@ class MyModel(base_schema.SchemaBaseFirebird, BASE):
     date_created = Column(
         DateTime,
         index=True,
-        server_default=text('CURRENT_TIMESTAMP'),
-        comment='Date and time when a row was inserted, defaults to current time',
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date and time when a row was inserted, defaults to current time",
     )
 
     # The date and time when a particular row was last updated. It defaults to
     # the current time whenever the instance is updated.
     date_updated = Column(
         DateTime,
         index=True,
-        server_default=text('CURRENT_TIMESTAMP'),
-        onupdate=text('CURRENT_TIMESTAMP'),
-        comment='Date and time when a row was last updated, defaults to current time on update',
+        server_default=text("CURRENT_TIMESTAMP"),
+        onupdate=text("CURRENT_TIMESTAMP"),
+        comment="Date and time when a row was last updated, defaults to current time on update",
     )
 
 
@@ -464,7 +468,7 @@ class MyModel(base_schema.SchemaBaseSybase, BASE):
     date_created = Column(
         DateTime,
         index=True,
-        server_default=text('GETUTCDATE()'),
+        server_default=text("GETUTCDATE()"),
         comment=date_created_comment,
     )
 
@@ -473,8 +477,8 @@ class MyModel(base_schema.SchemaBaseSybase, BASE):
     date_updated = Column(
         DateTime,
         index=True,
-        server_default=text('GETUTCDATE()'),
-        onupdate=text('GETUTCDATE()'),
+        server_default=text("GETUTCDATE()"),
+        onupdate=text("GETUTCDATE()"),
         comment=date_updated_comment,
     )
 

dsg_lib/async_database_functions/base_schema.py

@@ -67,7 +67,9 @@
     String,  # The String class from SQLAlchemy
     func,  # The func object from SQLAlchemy
     NoResultFound,  # The NoResultFound exception from SQLAlchemy
-) = import_sqlalchemy()  # Call the function that imports SQLAlchemy and checks its version
+) = (
+    import_sqlalchemy()
+)  # Call the function that imports SQLAlchemy and checks its version
 
 
 # Now you can use declarative_base at the module level
@@ -118,15 +120,15 @@ class DBConfig:
     """
 
     SUPPORTED_PARAMETERS = {
-        'sqlite': {'echo', 'future', 'pool_recycle'},
-        'postgresql': {
-            'echo',
-            'future',
-            'pool_pre_ping',
-            'pool_size',
-            'max_overflow',
-            'pool_recycle',
-            'pool_timeout',
+        "sqlite": {"echo", "future", "pool_recycle"},
+        "postgresql": {
+            "echo",
+            "future",
+            "pool_pre_ping",
+            "pool_size",
+            "max_overflow",
+            "pool_recycle",
+            "pool_timeout",
         },
         # Add other engines here...
     }
@@ -175,11 +177,15 @@ def __init__(self, config: Dict):
         ```
         """
         self.config = config
-        engine_type = self.config['database_uri'].split('+')[0]
+        engine_type = self.config["database_uri"].split("+")[0]
         supported_parameters = self.SUPPORTED_PARAMETERS.get(engine_type, set())
-        unsupported_parameters = set(config.keys()) - supported_parameters - {'database_uri'}
+        unsupported_parameters = (
+            set(config.keys()) - supported_parameters - {"database_uri"}
+        )
         if unsupported_parameters:
-            error_message = f'Unsupported parameters for {engine_type}: {unsupported_parameters}'
+            error_message = (
+                f"Unsupported parameters for {engine_type}: {unsupported_parameters}"
+            )
             logger.error(error_message)
             raise Exception(error_message)
 
@@ -188,7 +194,9 @@ def __init__(self, config: Dict):
             for param in supported_parameters
             if self.config.get(param) is not None
         }
-        self.engine = create_async_engine(self.config['database_uri'], **engine_parameters)
+        self.engine = create_async_engine(
+            self.config["database_uri"], **engine_parameters
+        )
         self.metadata = MetaData()
 
     @asynccontextmanager
@@ -229,7 +237,7 @@ async def get_db_session(self):
             # Perform your database operations here pass
         ```
         """
-        logger.debug('Creating new database session')
+        logger.debug("Creating new database session")
         try:
             # Create a new database session
             async with sessionmaker(
@@ -239,8 +247,8 @@ async def get_db_session(self):
                 yield session
         except SQLAlchemyError as e:  # pragma: no cover
             # Log the error and raise it
-            logger.error(f'Database error occurred: {str(e)}')  # pragma: no cover
+            logger.error(f"Database error occurred: {str(e)}")  # pragma: no cover
             raise  # pragma: no cover
         finally:  # pragma: no cover
             # Log the end of the database session
-            logger.debug('Database session ended')  # pragma: no cover
+            logger.debug("Database session ended")  # pragma: no cover