wcp-library 1.2.9__tar.gz → 1.3.1__tar.gz

{wcp_library-1.2.9 → wcp_library-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wcp-library
-Version: 1.2.9
+Version: 1.3.1
 Summary: Common utilites for internal development at WCP
 Home-page: https://github.com/Whitecap-DNA/WCP-Library
 Author: Mitch-Petersen

{wcp_library-1.2.9 → wcp_library-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wcp-library"
-version = "1.2.9"
+version = "1.3.1"
 description = "Common utilites for internal development at WCP"
 authors = ["Mitch-Petersen <mitch.petersen@wcap.ca>"]
 readme = "README.md"

wcp_library-1.2.9/wcp_library/async_credentials/oracle.py → wcp_library-1.3.1/wcp_library/credentials/credential_manager_asynchronous.py

@@ -1,4 +1,5 @@
 import logging
+from abc import ABC,abstractmethod
 
 import aiohttp
 from yarl import URL
@@ -8,12 +9,12 @@ from wcp_library.async_credentials import MissingCredentialsError
 logger = logging.getLogger(__name__)
 
 
-class AsyncOracleCredentialManager:
-    def __init__(self, passwordState_api_key: str):
+class AsyncCredentialManager(ABC):
+    def __init__(self, passwordState_api_key: str, password_list_id: int):
         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
+        self._password_list_id = password_list_id
 
     async def _get_credentials(self) -> dict:
         """
@@ -40,6 +41,46 @@ class AsyncOracleCredentialManager:
         logger.debug("Credentials retrieved")
         return password_dict
 
+    async def _get_credential(self, password_id: int) -> dict:
+        """
+        Get a specific credential from the password list
+
+        :param password_id:
+        :return:
+        """
+
+        logger.debug(f"Getting credential with ID {password_id}")
+        url = (self.password_url / str(password_id))
+        async with aiohttp.ClientSession() as session:
+            async with session.get(str(url), headers=self.headers) as response:
+                password = await response.json()
+
+        if not password:
+            raise MissingCredentialsError(f"No credentials found with ID {password_id}")
+        password = password[0]
+
+        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']
+        return password_info
+
+    async def _publish_new_password(self, data: dict) -> bool:
+        """
+        Publish a new password to the password list
+
+        :param data:
+        :return:
+        """
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(str(self.password_url), json=data, headers=self.headers) as response:
+                if response.status == 201:
+                    logger.debug(f"New credentials for {data['UserName']} created")
+                    return True
+                else:
+                    logger.error(f"Failed to create new credentials for {data['UserName']}")
+                    return False
+
     async def get_credentials(self, username: str) -> dict:
         """
         Get the credentials for a specific username
@@ -94,38 +135,6 @@ class AsyncOracleCredentialManager:
                     logger.error(f"Failed to update credentials for {credentials_dict['UserName']}")
                     return False
 
+    @abstractmethod
     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.post(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
+        raise NotImplementedError("Must override in child class")

wcp_library-1.2.9/wcp_library/credentials/postgres.py → wcp_library-1.3.1/wcp_library/credentials/credential_manager_synchronous.py

@@ -1,4 +1,5 @@
 import logging
+from abc import ABC,abstractmethod
 
 import requests
 from yarl import URL
@@ -8,12 +9,12 @@ from wcp_library.credentials import MissingCredentialsError
 logger = logging.getLogger(__name__)
 
 
-class PostgresCredentialManager:
-    def __init__(self, passwordState_api_key: str):
+class CredentialManager(ABC):
+    def __init__(self, passwordState_api_key: str, password_list_id: int):
         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
+        self._password_list_id = password_list_id
 
     def _get_credentials(self) -> dict:
         """
@@ -38,6 +39,44 @@ class PostgresCredentialManager:
         logger.debug("Credentials retrieved")
         return password_dict
 
+    def _get_credential(self, password_id: int) -> dict:
+        """
+        Get a specific credential from the password list
+
+        :param password_id:
+        :return:
+        """
+
+        logger.debug(f"Getting credential with ID {password_id}")
+        url = (self.password_url / str(password_id))
+        password = requests.get(str(url), headers=self.headers).json()
+
+        if not password:
+            raise MissingCredentialsError(f"No credentials found with ID {password_id}")
+        password = password[0]
+
+        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']
+        logger.debug("Credential retrieved")
+        return password_info
+
+    def _publish_new_password(self, data: dict) -> bool:
+        """
+        Publish a new password to the password list
+
+        :param data:
+        :return:
+        """
+
+        response = requests.post(str(self.password_url), json=data, headers=self.headers)
+        if response.status_code == 201:
+            logger.debug(f"New credentials for {data['UserName']} created")
+            return True
+        else:
+            logger.error(f"Failed to create new credentials for {data['UserName']}")
+            return False
+
     def get_credentials(self, username: str) -> dict:
         """
         Get the credentials for a specific username
@@ -56,6 +95,17 @@ class PostgresCredentialManager:
         logger.debug(f"Credentials for {username} retrieved")
         return return_credential
 
+    def get_credential_from_id(self, password_id: int) -> dict:
+        """
+        Get the credentials for a specific password ID
+
+        :param password_id:
+        :return:
+        """
+
+        return self._get_credential(password_id)
+
+
     def update_credential(self, credentials_dict: dict) -> bool:
         """
         Update the credentials for a specific username
@@ -89,36 +139,6 @@ class PostgresCredentialManager:
             logger.error(f"Failed to update credentials for {credentials_dict['UserName']}")
             return False
 
+    @abstractmethod
     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: True if successful, False otherwise
-        """
-
-        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']
-        }
-
-        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
+        raise NotImplementedError("Must override in child class")

wcp_library-1.3.1/wcp_library/credentials/ftp.py

@@ -0,0 +1,72 @@
+import logging
+
+from wcp_library.credentials.credential_manager_asynchronous import AsyncCredentialManager
+from wcp_library.credentials.credential_manager_synchronous import CredentialManager
+
+logger = logging.getLogger(__name__)
+
+
+class FTPCredentialManager(CredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 208)
+
+    def new_credentials(self, credentials_dict: dict) -> bool:
+        """
+        Create a new credential entry
+
+        Credentials dictionary must have the following keys:
+            - UserName
+            - Password
+            - Host
+            - Port
+            - FTP/SFTP (FTP or SFTP)
+
+        :param credentials_dict:
+        :return: True if successful, False otherwise
+        """
+
+        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['FTP/SFTP']
+        }
+
+        return self._publish_new_password(data)
+
+
+class AsyncFTPCredentialManager(AsyncCredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 208)
+
+    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
+            - FTP/SFTP (FTP or SFTP)
+
+        :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['FTP/SFTP']
+        }
+
+        return await self._publish_new_password(data)

wcp_library-1.3.1/wcp_library/credentials/oracle.py

@@ -0,0 +1,77 @@
+import logging
+
+import aiohttp
+
+from wcp_library.credentials.credential_manager_asynchronous import AsyncCredentialManager
+from wcp_library.credentials.credential_manager_synchronous import CredentialManager
+
+logger = logging.getLogger(__name__)
+
+
+class OracleCredentialManager(CredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 207)
+
+    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: True if successful, False otherwise
+        """
+
+        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
+        }
+
+        return self._publish_new_password(data)
+
+
+class AsyncOracleCredentialManager(AsyncCredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 207)
+
+    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
+        }
+
+        return await self._publish_new_password(data)
+

wcp_library-1.3.1/wcp_library/credentials/postgres.py

@@ -0,0 +1,72 @@
+import logging
+
+from wcp_library.credentials.credential_manager_asynchronous import AsyncCredentialManager
+from wcp_library.credentials.credential_manager_synchronous import CredentialManager
+
+logger = logging.getLogger(__name__)
+
+
+class PostgresCredentialManager(CredentialManager):
+    def __init__(self, passwordState_api_key: str):
+        super().__init__(passwordState_api_key, 210)
+
+    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: True if successful, False otherwise
+        """
+
+        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']
+        }
+
+        return self._publish_new_password(data)
+
+
+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
+
+        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']
+        }
+
+        return await self._publish_new_password(data)

{wcp_library-1.2.9/wcp_library/async_sql → wcp_library-1.3.1/wcp_library/sql}/__init__.py

@@ -1,6 +1,6 @@
-import asyncio
 import logging
 from functools import wraps
+from time import sleep
 
 import oracledb
 import psycopg
@@ -16,6 +16,33 @@ def retry(f: callable) -> callable:
     :return: function
     """
 
+    @wraps(f)
+    def wrapper(self, *args, **kwargs):
+        self._retry_count = 0
+        while True:
+            try:
+                return 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("Oracle connection error")
+                    logger.debug(error_obj.message)
+                    logger.info("Waiting 5 minutes before retrying Oracle connection")
+                    sleep(300)
+                else:
+                    raise e
+    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