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

wcp_library/async_sql/oracle.py

@@ -1,261 +0,0 @@
-import logging
-from typing import Optional
-
-import numpy as np
-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, 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 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']
-
-    @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 _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()
-
-    @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()
-
-    @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()
-
-    @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()
-
-    @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()
-
-    @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
-
-    @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)
-
-    @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)
-
-    @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)

wcp_library/async_sql/postgres.py

@@ -1,252 +0,0 @@
-import logging
-from typing import Optional
-
-import numpy as np
-import pandas as pd
-from psycopg.sql import SQL
-from psycopg_pool 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, 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
-    """
-
-    url = f"postgres://{username}:{password}@{hostname}:{port}/{database}"
-
-    session_pool = AsyncConnectionPool(
-        conninfo=url,
-        min_size=min_connections,
-        max_size=max_connections,
-    )
-    await session_pool.open()
-    return session_pool
-
-
-class AsyncPostgresConnection(object):
-    """
-    SQL Connection Class
-
-    :return: None
-    """
-
-    def __init__(self, min_connections: int = 2, max_connections: int = 5):
-        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._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 = ['08001', '08004']
-
-    @retry
-    async def _connect(self) -> None:
-        """
-        Connect to the warehouse
-
-        :return: None
-        """
-
-        self._session_pool = await _connect_warehouse(self._username, self._password, self._hostname, self._port,
-                                                      self._database, 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
-        """
-
-        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['Database']
-
-        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: SQL | str) -> None:
-        """
-        Execute the query
-
-        :param query: query
-        :return: None
-        """
-
-        async with self._session_pool.connection() as connection:
-            await connection.execute(query)
-
-    @retry
-    async def safe_execute(self, query: SQL | 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.connection() as connection:
-            await connection.execute(query, packed_values)
-
-    @retry
-    async def execute_multiple(self, queries: list[list[SQL | str, dict]]) -> None:
-        """
-        Execute multiple queries
-
-        :param queries: list of queries
-        :return: None
-        """
-
-        async with self._session_pool.connection() as connection:
-            for item in queries:
-                query = item[0]
-                packed_values = item[1]
-                if packed_values:
-                    await connection.execute(query, packed_values)
-                else:
-                    await connection.execute(query)
-
-    @retry
-    async def execute_many(self, query: SQL | str, dictionary: list[dict]) -> None:
-        """
-        Execute many queries
-
-        :param query: query
-        :param dictionary: dictionary of values
-        :return: None
-        """
-
-        async with self._session_pool.connection() as connection:
-            await connection.executemany(query, dictionary)
-
-    @retry
-    async def fetch_data(self, query: SQL | 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.connection() as connection:
-            cursor = connection.cursor()
-            if packed_data:
-                await cursor.execute(query, packed_data)
-            else:
-                await cursor.execute(query)
-            rows = await cursor.fetchall()
-        return rows
-
-    @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})s")
-        if len(param_list) > 1:
-            params = ' AND '.join(param_list)
-        else:
-            params = param_list[0]
-
-        main_dict = df.to_dict('records')
-        query = """DELETE FROM {} WHERE {}""".format(outputTableName, params)
-        await self.execute_many(query, main_dict)
-
-    @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)
-        param_list = []
-        for column in columns:
-            param_list.append(f"%({column})s")
-        params = ', '.join(param_list)
-
-        if remove_nan:
-            dfObj = dfObj.replace({np.nan: None})
-        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, params)
-        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)

wcp_library-1.2.9.dist-info/RECORD

@@ -1,25 +0,0 @@
-wcp_library/__init__.py,sha256=hwLbcu00uI6L_xjXO9-I0YcODl2WtIOkdNLoDcXv7zk,591
-wcp_library/async_credentials/__init__.py,sha256=ny6UitVV_xIecVzaWuHrJO9LpywBPke6u4C0F2wiM7o,1881
-wcp_library/async_credentials/api.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wcp_library/async_credentials/oracle.py,sha256=MvC7wsHnSyAyPGnRVlH0dvvW2xk5ap_IAByoHX4rUWY,5436
-wcp_library/async_credentials/postgres.py,sha256=3wjqtLH0Nc-U80iscYnz5DV-9M2X4IjPW51C5MI2_tI,5297
-wcp_library/async_sql/__init__.py,sha256=m4eWmUGYUEDomhhOp1ScB2uSIXFsNUNO589o5RwWdyM,1035
-wcp_library/async_sql/oracle.py,sha256=RgPvHHZmD6s1BlttjZ112-0VZ45M2J-essDR5-vpiDw,7965
-wcp_library/async_sql/postgres.py,sha256=oy0lybtd4i6PsiDabU0Ll-I-amuykawAgtqHNJUyPkM,7493
-wcp_library/credentials/__init__.py,sha256=HRmg7mqcATeclIz3lZQjSR4nmK6aY6MK9-QXEYZoFrw,1857
-wcp_library/credentials/ftp.py,sha256=FRxKVWifz7olQIrSjDgkTqk7rmc7Zdwmkfq7b62DQY8,4965
-wcp_library/credentials/oracle.py,sha256=IJVGd10LH5LUNKUSFAbApi0sjR1AbloMJRHTuR9zFrQ,5095
-wcp_library/credentials/postgres.py,sha256=VROORbeH5D0MW-0LYrtAm4_L29qJd7A1o9VQuloqZYw,4956
-wcp_library/emailing.py,sha256=xqNly6Tmj-pvwl5bdys3gauZFDd4SuWCQYzGFNemv2Q,2496
-wcp_library/ftp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wcp_library/ftp/ftp.py,sha256=EpyW0J2QIGxP8zVGD4VarA0hi4C2XAPDPF-0j2sRdpI,4350
-wcp_library/ftp/sftp.py,sha256=hykXGLGdxe7DYAxFdTwjPjTEOYuIpSMyK3NOiTQNUK0,4176
-wcp_library/informatica.py,sha256=IXZtk_9X1XLbOEwFrsyOwTgajQKvtXgANBHmuTOP3Kk,4064
-wcp_library/logging.py,sha256=e6gG7HFgUrMajUZs4Gs0atFfOJJmdmxN0GerfynNWlY,2061
-wcp_library/selenium_helper.py,sha256=rlphTXsUgnbaXZknY5nfQqxFhnc7UmrpzhV3hQ-cv7k,2509
-wcp_library/sql/__init__.py,sha256=CLlBEBrWVAwE79bUxuQiwikSrYH8m9QRYSJ2l0-ofsY,1003
-wcp_library/sql/oracle.py,sha256=hQxhQdT6C9Z1wZ-BGw2LYuoIgx5-ThJbEoo_ffOFSUc,7786
-wcp_library/sql/postgres.py,sha256=TE6U0EvKZ1BwQXRDdcX6SUu9z_9eno4RIf1pY0F1c0Q,7090
-wcp_library-1.2.9.dist-info/METADATA,sha256=6nNemO2bCgxhiWcSeuFqwZYUdkFmTtKK0Lt0SnLyDnI,1513
-wcp_library-1.2.9.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-wcp_library-1.2.9.dist-info/RECORD,,