wcp-library 1.2.8__py3-none-any.whl → 1.3.1__py3-none-any.whl

wcp_library/credentials/postgres.py

@@ -1,95 +1,49 @@
 import logging
 
-import requests
-from yarl import URL
-
-from wcp_library.credentials import MissingCredentialsError
+from wcp_library.credentials.credential_manager_asynchronous import AsyncCredentialManager
+from wcp_library.credentials.credential_manager_synchronous import CredentialManager
 
 logger = logging.getLogger(__name__)
 
 
-class PostgresCredentialManager:
+class PostgresCredentialManager(CredentialManager):
     def __init__(self, passwordState_api_key: str):
-        self.password_url = URL("https://vault.wcap.ca/api/passwords/")
-        self.api_key = passwordState_api_key
-        self.headers = {"APIKey": self.api_key, 'Reason': 'Python Script Access'}
-        self._password_list_id = 210
-
-    def _get_credentials(self) -> dict:
-        """
-        Get all credentials from the password list
-
-        :return: Dictionary of credentials
-        """
+        super().__init__(passwordState_api_key, 210)
 
-        logger.debug("Getting credentials from PasswordState")
-        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
-        passwords = requests.get(str(url), headers=self.headers).json()
-
-        if not passwords:
-            raise MissingCredentialsError("No credentials found in this Password List")
-
-        password_dict = {}
-        for password in passwords:
-            password_info = {'PasswordID': password['PasswordID'], 'UserName': password['UserName'], 'Password': password['Password']}
-            for field in password['GenericFieldInfo']:
-                password_info[field['DisplayName']] = field['Value'].lower() if field['DisplayName'].lower() == 'username' else field['Value']
-            password_dict[password['UserName'].lower()] = password_info
-        logger.debug("Credentials retrieved")
-        return password_dict
-
-    def get_credentials(self, username: str) -> dict:
-        """
-        Get the credentials for a specific username
-
-        :param username:
-        :return: Dictionary of credentials
-        """
-
-        logger.debug(f"Getting credentials for {username}")
-        credentials = self._get_credentials()
-
-        try:
-            return_credential = credentials[username.lower()]
-        except KeyError:
-            raise MissingCredentialsError(f"Credentials for {username} not found in this Password List")
-        logger.debug(f"Credentials for {username} retrieved")
-        return return_credential
-
-    def update_credential(self, credentials_dict: dict) -> bool:
+    def new_credentials(self, credentials_dict: dict) -> bool:
         """
-        Update the credentials for a specific username
+        Create a new credential entry
 
         Credentials dictionary must have the following keys:
-            - PasswordID
             - UserName
             - Password
-
-        The dictionary should be obtained from the get_credentials method and modified accordingly
+            - Host
+            - Port
+            - Database
 
         :param credentials_dict:
         :return: True if successful, False otherwise
         """
 
-        logger.debug(f"Updating credentials for {credentials_dict['UserName']}")
-        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
-        passwords = requests.get(str(url), headers=self.headers).json()
+        data = {
+            "PasswordListID": self._password_list_id,
+            "Title": credentials_dict['UserName'].upper() if "Title" not in credentials_dict else credentials_dict['Title'].upper(),
+            "Notes": credentials_dict['Notes'] if 'Notes' in credentials_dict else None,
+            "UserName": credentials_dict['UserName'].lower(),
+            "Password": credentials_dict['Password'],
+            "GenericField1": credentials_dict['Host'],
+            "GenericField2": credentials_dict['Port'],
+            "GenericField3": credentials_dict['Database']
+        }
 
-        relevant_credential_entry = [x for x in passwords if x['UserName'] == credentials_dict['UserName']][0]
-        for field in relevant_credential_entry['GenericFieldInfo']:
-            if field['DisplayName'] in credentials_dict:
-                credentials_dict[field['GenericFieldID']] = credentials_dict[field['DisplayName']]
-                credentials_dict.pop(field['DisplayName'])
+        return self._publish_new_password(data)
 
-        response = requests.put(str(self.password_url), json=credentials_dict, headers=self.headers)
-        if response.status_code == 200:
-            logger.debug(f"Credentials for {credentials_dict['UserName']} updated")
-            return True
-        else:
-            logger.error(f"Failed to update credentials for {credentials_dict['UserName']}")
-            return False
 
-    def new_credentials(self, credentials_dict: dict) -> bool:
+class AsyncPostgresCredentialManager(AsyncCredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 210)
+
+    async def new_credentials(self, credentials_dict: dict) -> bool:
         """
         Create a new credential entry
 
@@ -101,7 +55,7 @@ class PostgresCredentialManager:
             - Database
 
         :param credentials_dict:
-        :return: True if successful, False otherwise
+        :return:
         """
 
         data = {
@@ -115,10 +69,4 @@ class PostgresCredentialManager:
             "GenericField3": credentials_dict['Database']
         }
 
-        response = requests.post(str(self.password_url), json=data, headers=self.headers)
-        if response.status_code == 201:
-            logger.debug(f"New credentials for {credentials_dict['UserName']} created")
-            return True
-        else:
-            logger.error(f"Failed to create new credentials for {credentials_dict['UserName']}")
-            return False
+        return await self._publish_new_password(data)

wcp_library/sql/__init__.py

@@ -32,4 +32,31 @@ def retry(f: callable) -> callable:
                     sleep(300)
                 else:
                     raise e
-    return wrapper
+    return wrapper
+
+
+def async_retry(f: callable) -> callable:
+    """
+    Decorator to retry a function
+
+    :param f: function
+    :return: function
+    """
+
+    @wraps(f)
+    async def wrapper(self, *args, **kwargs):
+        self._retry_count = 0
+        while True:
+            try:
+                return await f(self, *args, **kwargs)
+            except (oracledb.OperationalError, psycopg.OperationalError) as e:
+                error_obj, = e.args
+                if error_obj.full_code in self.retry_error_codes and self._retry_count < self.retry_limit:
+                    self._retry_count += 1
+                    logger.debug(f"{self._db_service} connection error")
+                    logger.debug(error_obj.message)
+                    logger.info("Waiting 5 minutes before retrying Oracle connection")
+                    await asyncio.sleep(300)
+                else:
+                    raise e
+    return wrapper

wcp_library/sql/oracle.py

@@ -4,9 +4,9 @@ from typing import Optional
 import numpy as np
 import pandas as pd
 import oracledb
-from oracledb import ConnectionPool
+from oracledb import ConnectionPool, AsyncConnectionPool
 
-from wcp_library.sql import retry
+from wcp_library.sql import retry, async_retry
 
 logger = logging.getLogger(__name__)
 
@@ -38,6 +38,36 @@ def _connect_warehouse(username: str, password: str, hostname: str, port: int, d
     return session_pool
 
 
+async def _async_connect_warehouse(username: str, password: str, hostname: str, port: int, database: str,
+                                   min_connections: int, max_connections: int) -> AsyncConnectionPool:
+    """
+    Create Warehouse Connection
+
+    :param username: username
+    :param password: password
+    :param hostname: hostname
+    :param port: port
+    :param database: database
+    :param min_connections:
+    :param max_connections:
+    :return: session_pool
+    """
+
+    dsn = oracledb.makedsn(hostname, port, sid=database)
+    session_pool = oracledb.create_pool_async(
+        user=username,
+        password=password,
+        dsn=dsn,
+        min=min_connections,
+        max=max_connections,
+        increment=1
+    )
+    return session_pool
+
+
+"""~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"""
+
+
 class OracleConnection(object):
     """
     SQL Connection Class
@@ -206,7 +236,10 @@ class OracleConnection(object):
         param_list = []
         for column in match_cols:
             param_list.append(f"{column} = :{column}")
-        params = ' AND '.join(param_list)
+        if len(param_list) > 1:
+            params = ' AND '.join(param_list)
+        else:
+            params = param_list[0]
 
         main_dict = df.to_dict('records')
         query = f"""DELETE FROM {outputTableName} WHERE {params}"""
@@ -269,3 +302,226 @@ class OracleConnection(object):
         """
 
         self._session_pool.close()
+
+
+class AsyncOracleConnection(object):
+    """
+    SQL Connection Class
+
+    :return: None
+    """
+
+    def __init__(self, min_connections: int = 2, max_connections: int = 5):
+        self._db_service: str = "Oracle"
+        self._username: Optional[str] = None
+        self._password: Optional[str] = None
+        self._hostname: Optional[str] = None
+        self._port: Optional[int] = None
+        self._database: Optional[str] = None
+        self._sid: Optional[str] = None
+        self._session_pool: Optional[AsyncConnectionPool] = None
+
+        self.min_connections = min_connections
+        self.max_connections = max_connections
+
+        self._retry_count = 0
+        self.retry_limit = 50
+        self.retry_error_codes = ['ORA-01033', 'DPY-6005', 'DPY-4011']
+
+    @async_retry
+    async def _connect(self) -> None:
+        """
+        Connect to the warehouse
+
+        :return: None
+        """
+
+        sid_or_service = self._database if self._database else self._sid
+
+        self._session_pool = await _async_connect_warehouse(self._username, self._password, self._hostname, self._port,
+                                                            sid_or_service, self.min_connections, self.max_connections)
+
+    async def set_user(self, credentials_dict: dict) -> None:
+        """
+        Set the user credentials and connect
+
+        :param credentials_dict: dictionary of connection details
+        :return: None
+        """
+
+        if not ([credentials_dict['Service'] or credentials_dict['SID']]):
+            raise ValueError("Either Service or SID must be provided")
+
+        self._username: Optional[str] = credentials_dict['UserName']
+        self._password: Optional[str] = credentials_dict['Password']
+        self._hostname: Optional[str] = credentials_dict['Host']
+        self._port: Optional[int] = int(credentials_dict['Port'])
+        self._database: Optional[str] = credentials_dict['Service'] if 'Service' in credentials_dict else None
+        self._sid: Optional[str] = credentials_dict['SID'] if 'SID' in credentials_dict else None
+
+        await self._connect()
+
+    async def close_connection(self) -> None:
+        """
+        Close the connection
+
+        :return: None
+        """
+
+        await self._session_pool.close()
+
+    @async_retry
+    async def execute(self, query: str) -> None:
+        """
+        Execute the query
+
+        :param query: query
+        :return: None
+        """
+
+        async with self._session_pool.acquire() as connection:
+            with connection.cursor() as cursor:
+                await cursor.execute(query)
+                await connection.commit()
+
+    @async_retry
+    async def safe_execute(self, query: str, packed_values: dict) -> None:
+        """
+        Execute the query without SQL Injection possibility, to be used with external facing projects.
+
+        :param query: query
+        :param packed_values: dictionary of values
+        :return: None
+        """
+
+        async with self._session_pool.acquire() as connection:
+            with connection.cursor() as cursor:
+                await cursor.execute(query, packed_values)
+                await connection.commit()
+
+    @async_retry
+    async def execute_multiple(self, queries: list[list[str, dict]]) -> None:
+        """
+        Execute multiple queries
+
+        :param queries: list of queries
+        :return: None
+        """
+
+        async with self._session_pool.acquire() as connection:
+            with connection.cursor() as cursor:
+                for item in queries:
+                    query = item[0]
+                    packed_values = item[1]
+                    if packed_values:
+                        await cursor.execute(query, packed_values)
+                    else:
+                        await cursor.execute(query)
+                await connection.commit()
+
+    @async_retry
+    async def execute_many(self, query: str, dictionary: list[dict]) -> None:
+        """
+        Execute many queries
+
+        :param query: query
+        :param dictionary: dictionary of values
+        :return: None
+        """
+
+        async with self._session_pool.acquire() as connection:
+            with connection.cursor() as cursor:
+                await cursor.executemany(query, dictionary)
+                await connection.commit()
+
+    @async_retry
+    async def fetch_data(self, query: str, packed_data=None):
+        """
+        Fetch the data from the query
+
+        :param query: query
+        :param packed_data: packed data
+        :return: rows
+        """
+
+        async with self._session_pool.acquire() as connection:
+            with connection.cursor() as cursor:
+                if packed_data:
+                    await cursor.execute(query, packed_data)
+                else:
+                    await cursor.execute(query)
+                rows = await cursor.fetchall()
+        return rows
+
+    @async_retry
+    async def remove_matching_data(self, dfObj: pd.DataFrame, outputTableName: str, match_cols: list) -> None:
+        """
+        Remove matching data from the warehouse
+
+        :param dfObj: DataFrame
+        :param outputTableName: output table name
+        :param match_cols: list of columns
+        :return: None
+        """
+
+        df = dfObj[match_cols]
+        param_list = []
+        for column in match_cols:
+            param_list.append(f"{column} = :{column}")
+        if len(param_list) > 1:
+            params = ' AND '.join(param_list)
+        else:
+            params = param_list[0]
+
+        main_dict = df.to_dict('records')
+        query = f"""DELETE FROM {outputTableName} WHERE {params}"""
+        await self.execute_many(query, main_dict)
+
+    @async_retry
+    async def export_DF_to_warehouse(self, dfObj: pd.DataFrame, outputTableName: str, columns: list, remove_nan=False) -> None:
+        """
+        Export the DataFrame to the warehouse
+
+        :param dfObj: DataFrame
+        :param outputTableName: output table name
+        :param columns: list of columns
+        :param remove_nan: remove NaN values
+        :return: None
+        """
+
+        col = ', '.join(columns)
+        bindList = []
+        for column in columns:
+            bindList.append(':' + column)
+        bind = ', '.join(bindList)
+
+        if remove_nan:
+            dfObj = dfObj.replace({np.nan: None})
+        main_dict = dfObj.to_dict('records')
+
+        query = """INSERT INTO {} ({}) VALUES ({})""".format(outputTableName, col, bind)
+        await self.execute_many(query, main_dict)
+
+    @async_retry
+    async def truncate_table(self, tableName: str) -> None:
+        """
+        Truncate the table
+
+        :param tableName: table name
+        :return: None
+        """
+
+        truncateQuery = """TRUNCATE TABLE {}""".format(tableName)
+        await self.execute(truncateQuery)
+
+    @async_retry
+    async def empty_table(self, tableName: str) -> None:
+        """
+        Empty the table
+
+        :param tableName: table name
+        :return: None
+        """
+
+        deleteQuery = """DELETE FROM {}""".format(tableName)
+        await self.execute(deleteQuery)