wcp-library 1.0.0__py3-none-any.whl

wcp_library/__init__.py

@@ -0,0 +1,14 @@
+import os
+import sys
+from pathlib import Path
+
+# PyInstaller import
+import pip_system_certs.wrapt_requests
+
+
+# Application Path
+if getattr(sys, 'frozen', False):
+    application_path = sys.executable + '-'
+    application_path = Path(application_path).parent
+else:
+    application_path = Path(os.path.dirname(os.path.abspath(__file__)))

wcp_library/async_credentials/__init__.py

@@ -0,0 +1,49 @@
+import secrets
+import string
+
+
+class MissingCredentialsError(KeyError):
+    pass
+
+
+async def generate_password(length: int=12, use_nums: bool=True, use_special: bool=True, special_chars_override: list=None, force_num: bool=True, force_spec: bool=True) -> str:
+    """
+    Function to generate a random password
+
+    :param length:
+    :param use_nums: Allows the use of numbers
+    :param use_special: Allows the use of special characters
+    :param special_chars_override: List of special characters to use
+    :param force_num: Requires the password to contain at least one number
+    :param force_spec: Requires the password to contain at least one special character
+    :return: Password
+    """
+
+    letters = string.ascii_letters
+    digits = string.digits
+    if special_chars_override:
+        special_chars = special_chars_override
+    else:
+        special_chars = string.punctuation
+
+    alphabet = letters
+    if use_nums:
+        alphabet += digits
+    if use_special:
+        alphabet += special_chars
+
+    pwd = ''
+    for i in range(length):
+        pwd += ''.join(secrets.choice(alphabet))
+
+    if (use_nums and force_num) and (use_special and force_spec):
+        while pwd[0].isdigit() or not any(char.isdigit() for char in pwd) or not any(char in pwd for char in special_chars):
+            pwd = await generate_password(length, use_nums, use_special, special_chars_override, force_num, force_spec)
+    elif use_nums and force_num:
+        while pwd[0].isdigit() or not any(char.isdigit() for char in pwd):
+            pwd = await generate_password(length, use_nums, use_special, special_chars_override, force_num, force_spec)
+    elif use_special and force_spec:
+        while not any(char in pwd for char in special_chars):
+            pwd = await generate_password(length, use_nums, use_special, special_chars_override, force_num, force_spec)
+
+    return pwd

wcp_library/async_credentials/oracle.py

@@ -0,0 +1,131 @@
+import logging
+
+import aiohttp
+from yarl import URL
+
+from WCP_Library.async_credentials import MissingCredentialsError
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncOracleCredentialManager:
+    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 = 207
+
+    async def _get_credentials(self) -> dict:
+        """
+        Get all credentials from the password list
+
+        :return:
+        """
+
+        logger.debug("Getting credentials from PasswordState")
+        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(url), headers=self.headers) as response:
+                passwords = await response.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
+
+    async def get_credentials(self, username: str) -> dict:
+        """
+        Get the credentials for a specific username
+
+        :param username:
+        :return:
+        """
+
+        logger.debug(f"Getting credentials for {username}")
+        credentials = await 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
+
+    async def update_credential(self, credentials_dict: dict) -> bool:
+        """
+        Update username and password in PasswordState
+
+        Credentials dictionary must have the following keys:
+            - PasswordID
+            - UserName
+            - Password
+
+        The dictionary can be obtained from the get_credentials method
+
+        :param credentials_dict:
+        :return:
+        """
+
+        logger.debug(f"Updating credentials for {credentials_dict['UserName']}")
+        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(url), headers=self.headers) as response:
+                passwords = await response.json()
+
+        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'])
+
+        async with aiohttp.ClientSession() as session:
+            async with session.put(str(self.password_url), json=credentials_dict, headers=self.headers) as response:
+                if response.status == 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
+
+    async def new_credentials(self, credentials_dict: dict) -> bool:
+        """
+        Create a new credential entry
+
+        Credentials dictionary must have the following keys:
+            - UserName
+            - Password
+            - Host
+            - Port
+            - Service or SID
+
+        :param credentials_dict:
+        :return:
+        """
+
+        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['Service'] if 'Service' in credentials_dict else None,
+            "GenericField4": credentials_dict['SID'] if 'SID' in credentials_dict else None
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.put(str(self.password_url), json=data, headers=self.headers) as response:
+                if response.status == 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

wcp_library/async_credentials/postgres.py

@@ -0,0 +1,130 @@
+import logging
+
+import aiohttp
+from yarl import URL
+
+from WCP_Library.async_credentials import MissingCredentialsError
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncPostgresCredentialManager:
+    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 = 207
+
+    async def _get_credentials(self) -> dict:
+        """
+        Get all credentials from the password list
+
+        :return:
+        """
+
+        logger.debug("Getting credentials from PasswordState")
+        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(url), headers=self.headers) as response:
+                passwords = await response.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
+
+    async def get_credentials(self, username: str) -> dict:
+        """
+        Get the credentials for a specific username
+
+        :param username:
+        :return:
+        """
+
+        logger.debug(f"Getting credentials for {username}")
+        credentials = await 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
+
+    async def update_credential(self, credentials_dict: dict) -> bool:
+        """
+        Update username and password in PasswordState
+
+        Credentials dictionary must have the following keys:
+            - PasswordID
+            - UserName
+            - Password
+
+        The dictionary can be obtained from the get_credentials method
+
+        :param credentials_dict:
+        :return:
+        """
+
+        logger.debug(f"Updating credentials for {credentials_dict['UserName']}")
+        url = (self.password_url / str(self._password_list_id)).with_query("QueryAll")
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(url), headers=self.headers) as response:
+                passwords = await response.json()
+
+        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'])
+
+        async with aiohttp.ClientSession() as session:
+            async with session.put(str(self.password_url), json=credentials_dict, headers=self.headers) as response:
+                if response.status == 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
+
+    async def new_credentials(self, credentials_dict: dict) -> bool:
+        """
+        Create a new credential entry
+
+        Credentials dictionary must have the following keys:
+            - UserName
+            - Password
+            - Host
+            - Port
+            - Database
+
+        :param credentials_dict:
+        :return:
+        """
+
+        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']
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.put(str(self.password_url), json=data, headers=self.headers) as response:
+                if response.status == 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

wcp_library/async_sql/__init__.py

@@ -0,0 +1,35 @@
+import asyncio
+import logging
+from functools import wraps
+
+import oracledb
+import psycopg
+
+logger = logging.getLogger(__name__)
+
+
+def 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/async_sql/oracle.py

@@ -0,0 +1,242 @@
+import logging
+from typing import Optional
+
+import pandas as pd
+import oracledb
+from oracledb import AsyncConnectionPool
+
+from WCP_Library.async_sql import retry
+
+logger = logging.getLogger(__name__)
+
+
+async def connect_warehouse(username: str, password: str, hostname: str, port: int, database: str) -> AsyncConnectionPool:
+    """
+    Create Warehouse Connection
+
+    :param username: username
+    :param password: password
+    :param hostname: hostname
+    :param port: port
+    :param database: database
+    :return: session_pool
+    """
+
+    dsn = oracledb.makedsn(hostname, port, sid=database)
+    session_pool = oracledb.create_pool_async(
+        user=username,
+        password=password,
+        dsn=dsn,
+        min=2,
+        max=5,
+        increment=1,
+        threaded=True,
+        encoding="UTF-8"
+    )
+    return session_pool
+
+
+class SQLConnection(object):
+    """
+    SQL Connection Class
+
+    :return: None
+    """
+
+    def __init__(self):
+        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._retry_count = 0
+        self.retry_limit = 50
+        self.retry_error_codes = ['ORA-01033', 'DPY-6005', 'DPY-4011']
+
+    @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 = connect_warehouse(self._username, self._password, self._hostname, self._port,
+                                               sid_or_service)
+
+    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 any([self._database, self._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()
+
+    @retry
+    async def execute(self, query: str) -> None:
+        """
+        Execute the query
+
+        :param query: query
+        :return: None
+        """
+
+        connection = self._session_pool.acquire()
+        cursor = connection.cursor()
+        await cursor.execute(query)
+        await connection.commit()
+        await self._session_pool.release(connection)
+
+    @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
+        """
+
+        connection = self._session_pool.acquire()
+        cursor = connection.cursor()
+        await cursor.execute(query, packed_values)
+        await connection.commit()
+        await self._session_pool.release(connection)
+
+    @retry
+    async def execute_multiple(self, queries: list[list[str, dict]]) -> None:
+        """
+        Execute multiple queries
+
+        :param queries: list of queries
+        :return: None
+        """
+
+        connection = self._session_pool.acquire()
+        cursor = connection.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()
+        await self._session_pool.release(connection)
+
+    @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
+        """
+
+        connection = self._session_pool.acquire()
+        cursor = connection.cursor()
+        await cursor.executemany(query, dictionary)
+        await connection.commit()
+        await self._session_pool.release(connection)
+
+    @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
+        """
+
+        connection = self._session_pool.acquire()
+        cursor = connection.cursor()
+        if packed_data:
+            await cursor.execute(query, packed_data)
+        else:
+            await cursor.execute(query)
+        rows = cursor.fetchall()
+        await self._session_pool.release(connection)
+        return rows
+
+    @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)
+
+        main_dict = dfObj.to_dict('records')
+        if remove_nan:
+            for val, item in enumerate(main_dict):
+                for sub_item, value in item.items():
+                    if pd.isna(value):
+                        main_dict[val][sub_item] = None
+                    else:
+                        main_dict[val][sub_item] = value
+
+        query = """INSERT INTO {} ({}) VALUES ({})""".format(outputTableName, col, bind)
+        await self.execute_many(query, main_dict)
+
+    @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)
+
+    @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)