pyplaykit 1.7.0__tar.gz → 1.8.0__tar.gz

{pyplaykit-1.7.0/pyplaykit.egg-info → pyplaykit-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyplaykit
-Version: 1.7.0
+Version: 1.8.0
 Summary: Enterprise Python + Playwright automation framework
 Author-email: Shan Konduru <shankonduru@gmail.com>
 License: MIT

{pyplaykit-1.7.0 → pyplaykit-1.8.0/pyplaykit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyplaykit
-Version: 1.7.0
+Version: 1.8.0
 Summary: Enterprise Python + Playwright automation framework
 Author-email: Shan Konduru <shankonduru@gmail.com>
 License: MIT

{pyplaykit-1.7.0 → pyplaykit-1.8.0}/pyplaykit.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ utils/data_comparison_utils.py
 utils/data_loader.py
 utils/data_source.py
 utils/data_validator.py
+utils/database_clients.py
 utils/db_client.py
 utils/db_factory.py
 utils/db_fixtures.py
@@ -82,6 +83,7 @@ utils/ui_db_validator.py
 utils/yaml_config_reader.py
 utils/db_drivers/__init__.py
 utils/db_drivers/db2.py
+utils/db_drivers/informix.py
 utils/db_drivers/mysql.py
 utils/db_drivers/oracle.py
 utils/db_drivers/snowflake.py

{pyplaykit-1.7.0 → pyplaykit-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyplaykit"
-version = "1.7.0"
+version = "1.8.0"
 description = "Enterprise Python + Playwright automation framework"
 readme = "README.md"
 license = { text = "MIT" }

pyplaykit-1.8.0/utils/database_clients.py

@@ -0,0 +1,424 @@
+"""
+Custom database client wrappers for cross-database comparisons.
+
+PyPlayKit's built-in db_client fixture supports PostgreSQL by default.
+Use these wrappers to compare other enterprise database types:
+- SQL Server
+- Oracle
+- DB2
+- Informix
+
+DEPRECATED: This module is superseded by the unified driver architecture in
+utils/db_drivers/ and utils/db_factory.py. Use DbClientFactory.create() instead.
+
+For new code, prefer:
+    from utils.db_factory import DbClientFactory
+    client = DbClientFactory.create("sqlserver", host="...", ...)
+
+Legacy Installation:
+    pip install cx_Oracle      # Oracle
+    pip install pyodbc          # SQL Server
+    pip install ibm_db          # DB2
+    pip install IfxPy           # Informix
+
+Legacy Usage:
+    from utils.database_clients import OracleClient, SQLServerClient, DB2Client, InformixClient
+
+    oracle = OracleClient(user="...", password="...", dsn="...")
+    results = oracle.fetch_all("SELECT * FROM customers")
+    oracle.close()
+"""
+
+from typing import Any
+
+
+class DatabaseClient:
+    """Base class for all database clients."""
+
+    def fetch_all(self, query: str, params: tuple = ()) -> list[dict[str, Any]]:
+        """
+        Execute query and return results as list of dictionaries.
+
+        Args:
+            query: SQL query to execute
+            params: Query parameters (default: ())
+
+        Returns:
+            List of dictionaries where each dict represents one row
+
+        Example:
+            results = client.fetch_all("SELECT id, name FROM users WHERE id = %s", (123,))
+            # Returns: [{"id": 123, "name": "Alice"}]
+        """
+        raise NotImplementedError("Subclasses must implement fetch_all()")
+
+    def close(self):
+        """Close database connection."""
+        raise NotImplementedError("Subclasses must implement close()")
+
+
+class OracleClient(DatabaseClient):
+    """
+    Oracle database client wrapper.
+
+    Installation:
+        pip install cx_Oracle
+        # Also install Oracle Instant Client
+
+    Usage:
+        oracle = OracleClient(
+            user="oracle_user",
+            password="oracle_password",
+            dsn="hostname:1521/service_name"
+        )
+
+        results = oracle.fetch_all("SELECT * FROM CUSTOMERS ORDER BY ID")
+        oracle.close()
+
+    Column Names:
+        Automatically converts Oracle's uppercase column names to lowercase
+        for consistency with PostgreSQL/MySQL.
+    """
+
+    def __init__(self, user: str, password: str, dsn: str):
+        """
+        Initialize Oracle connection.
+
+        Args:
+            user: Oracle username
+            password: Oracle password
+            dsn: Data Source Name in format "host:port/service_name"
+                 Example: "oracle.example.com:1521/PROD"
+        """
+        try:
+            import cx_Oracle
+        except ImportError:
+            raise ImportError(
+                "cx_Oracle is required for Oracle connections. "
+                "Install with: pip install cx_Oracle"
+            )
+
+        self.connection = cx_Oracle.connect(user=user, password=password, dsn=dsn)
+
+    def fetch_all(self, query: str, params: tuple = ()) -> list[dict[str, Any]]:
+        """Execute query and return list of dictionaries."""
+        cursor = self.connection.cursor()
+        cursor.execute(query, params)
+
+        # Get column names (convert to lowercase for consistency)
+        columns = [desc[0].lower() for desc in cursor.description]
+
+        # Fetch all rows
+        rows = cursor.fetchall()
+
+        # Convert to list of dictionaries
+        result = [dict(zip(columns, row)) for row in rows]
+
+        cursor.close()
+        return result
+
+    def close(self):
+        """Close Oracle connection."""
+        if self.connection:
+            self.connection.close()
+
+
+class SQLServerClient(DatabaseClient):
+    """
+    SQL Server database client wrapper.
+
+    Installation:
+        pip install pyodbc
+        # Also install: ODBC Driver 17 for SQL Server
+
+    Windows:
+        Download ODBC Driver from Microsoft
+
+    Linux:
+        sudo apt-get install msodbcsql17
+
+    macOS:
+        brew tap microsoft/mssql-release
+        brew install msodbcsql17
+
+    Usage:
+        sqlserver = SQLServerClient(
+            server="sqlserver.example.com",
+            database="production",
+            username="sa",
+            password="password"
+        )
+
+        results = sqlserver.fetch_all("SELECT * FROM dbo.Customers")
+        sqlserver.close()
+
+    Column Names:
+        Automatically converts column names to lowercase for consistency.
+    """
+
+    def __init__(
+        self,
+        server: str,
+        database: str,
+        username: str,
+        password: str,
+        driver: str = "ODBC Driver 17 for SQL Server",
+        port: int = 1433
+    ):
+        """
+        Initialize SQL Server connection.
+
+        Args:
+            server: SQL Server hostname
+            database: Database name
+            username: SQL Server username
+            password: SQL Server password
+            driver: ODBC driver name (default: ODBC Driver 17 for SQL Server)
+            port: SQL Server port (default: 1433)
+        """
+        try:
+            import pyodbc
+        except ImportError:
+            raise ImportError(
+                "pyodbc is required for SQL Server connections. "
+                "Install with: pip install pyodbc"
+            )
+
+        conn_string = (
+            f"DRIVER={{{driver}}};"
+            f"SERVER={server},{port};"
+            f"DATABASE={database};"
+            f"UID={username};"
+            f"PWD={password}"
+        )
+        self.connection = pyodbc.connect(conn_string)
+
+    def fetch_all(self, query: str, params: tuple = ()) -> list[dict[str, Any]]:
+        """Execute query and return list of dictionaries."""
+        cursor = self.connection.cursor()
+        cursor.execute(query, params)
+
+        # Get column names (convert to lowercase)
+        columns = [column[0].lower() for column in cursor.description]
+
+        # Fetch all rows
+        rows = cursor.fetchall()
+
+        # Convert to list of dictionaries
+        result = [dict(zip(columns, row)) for row in rows]
+
+        cursor.close()
+        return result
+
+    def close(self):
+        """Close SQL Server connection."""
+        if self.connection:
+            self.connection.close()
+
+
+class DB2Client(DatabaseClient):
+    """
+    IBM DB2 database client wrapper.
+
+    Installation:
+        pip install ibm_db ibm_db_dbi
+
+    Usage:
+        db2 = DB2Client(
+            host="db2.example.com",
+            port=50000,
+            database="PRODDB",
+            user="db2user",
+            password="password"
+        )
+
+        results = db2.fetch_all("SELECT * FROM CUSTOMERS ORDER BY ID")
+        db2.close()
+
+    Column Names:
+        Automatically converts DB2's uppercase column names to lowercase
+        for consistency with PostgreSQL.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        database: str,
+        user: str,
+        password: str,
+        connect_timeout: int = 10
+    ):
+        """
+        Initialize DB2 connection.
+
+        Args:
+            host: DB2 hostname
+            port: DB2 port (default: 50000)
+            database: Database name
+            user: DB2 username
+            password: DB2 password
+            connect_timeout: Connection timeout in seconds
+        """
+        try:
+            import ibm_db
+            import ibm_db_dbi
+        except ImportError:
+            raise ImportError(
+                "ibm_db and ibm_db_dbi are required for DB2 connections. "
+                "Install with: pip install ibm_db ibm_db_dbi"
+            )
+
+        conn_str = (
+            f"DATABASE={database};"
+            f"HOSTNAME={host};"
+            f"PORT={port};"
+            f"PROTOCOL=TCPIP;"
+            f"UID={user};"
+            f"PWD={password};"
+            f"ConnectTimeout={connect_timeout};"
+        )
+        raw_conn = ibm_db.connect(conn_str, "", "")
+        self.connection = ibm_db_dbi.Connection(raw_conn)
+
+    def fetch_all(self, query: str, params: tuple = ()) -> list[dict[str, Any]]:
+        """Execute query and return list of dictionaries."""
+        cursor = self.connection.cursor()
+        cursor.execute(query, params)
+
+        # Get column names (convert to lowercase for consistency)
+        columns = [desc[0].lower() for desc in cursor.description]
+
+        # Fetch all rows
+        rows = cursor.fetchall()
+
+        # Convert to list of dictionaries
+        result = [dict(zip(columns, row)) for row in rows]
+
+        cursor.close()
+        return result
+
+    def close(self):
+        """Close DB2 connection."""
+        if self.connection:
+            self.connection.close()
+
+
+class InformixClient(DatabaseClient):
+    """
+    IBM Informix database client wrapper.
+
+    Installation:
+        pip install IfxPy IfxPyDbi
+
+    Usage:
+        informix = InformixClient(
+            host="informix.example.com",
+            port=9088,
+            database="stores",
+            server="informix_tcp",
+            user="informix",
+            password="password"
+        )
+
+        results = informix.fetch_all("SELECT * FROM customer ORDER BY customer_num")
+        informix.close()
+
+    Column Names:
+        Automatically converts column names to lowercase for consistency.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        database: str,
+        server: str,
+        user: str,
+        password: str,
+        connect_timeout: int = 10
+    ):
+        """
+        Initialize Informix connection.
+
+        Args:
+            host: Informix hostname
+            port: Informix port (default: 9088)
+            database: Database name
+            server: Informix server name (e.g., "informix_tcp")
+            user: Informix username
+            password: Informix password
+            connect_timeout: Connection timeout in seconds
+        """
+        try:
+            import IfxPy
+            import IfxPyDbi
+        except ImportError:
+            raise ImportError(
+                "IfxPy and IfxPyDbi are required for Informix connections. "
+                "Install with: pip install IfxPy IfxPyDbi"
+            )
+
+        conn_str = (
+            f"SERVER={server};"
+            f"DATABASE={database};"
+            f"HOST={host};"
+            f"SERVICE={port};"
+            f"UID={user};"
+            f"PWD={password};"
+            f"PROTOCOL=onsoctcp;"
+            f"ConnectTimeout={connect_timeout};"
+        )
+        raw_conn = IfxPy.connect(conn_str, "", "")
+        self.connection = IfxPyDbi.Connection(raw_conn)
+
+    def fetch_all(self, query: str, params: tuple = ()) -> list[dict[str, Any]]:
+        """Execute query and return list of dictionaries."""
+        cursor = self.connection.cursor()
+        cursor.execute(query, params)
+
+        # Get column names (convert to lowercase for consistency)
+        columns = [desc[0].lower() for desc in cursor.description]
+
+        # Fetch all rows
+        rows = cursor.fetchall()
+
+        # Convert to list of dictionaries
+        result = [dict(zip(columns, row)) for row in rows]
+
+        cursor.close()
+        return result
+
+    def close(self):
+        """Close Informix connection."""
+        if self.connection:
+            self.connection.close()
+
+
+# Context manager support for all clients
+class DatabaseClientContextManager:
+    """Context manager wrapper for database clients."""
+
+    def __init__(self, client: DatabaseClient):
+        self.client = client
+
+    def __enter__(self):
+        return self.client
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+        return False
+
+
+# Make all clients usable as context managers
+OracleClient.__enter__ = lambda self: self
+OracleClient.__exit__ = lambda self, *args: self.close() or False
+
+SQLServerClient.__enter__ = lambda self: self
+SQLServerClient.__exit__ = lambda self, *args: self.close() or False
+
+DB2Client.__enter__ = lambda self: self
+DB2Client.__exit__ = lambda self, *args: self.close() or False
+
+InformixClient.__enter__ = lambda self: self
+InformixClient.__exit__ = lambda self, *args: self.close() or False

pyplaykit-1.8.0/utils/db_drivers/informix.py

@@ -0,0 +1,185 @@
+"""IBM Informix driver — requires: pip install IfxPy IfxPyDbi.
+
+Uses ``?`` as the parameter placeholder in queries.
+Schema and table names in Informix system catalogs are case-sensitive but
+typically stored in lowercase.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from utils.db_client import BaseDbClient
+
+
+class InformixClient(BaseDbClient):
+    """BaseDbClient implementation for IBM Informix."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 9088,
+        database: str = "",
+        server: str = "",
+        user: str = "",
+        password: str = "",
+        connect_timeout: int = 10,
+        logger=None,
+    ) -> None:
+        """
+        Initialize Informix client.
+
+        Args:
+            host: Informix server hostname
+            port: Informix server port (default: 9088)
+            database: Database name
+            server: Informix server name (e.g., "informix_tcp")
+            user: Database username
+            password: Database password
+            connect_timeout: Connection timeout in seconds
+            logger: Optional logger instance
+        """
+        self.host = host
+        self.port = port
+        self.database = database
+        self.server = server
+        self.user = user
+        self.password = password
+        self.connect_timeout = connect_timeout
+        self.logger = logger
+        self._conn = None
+
+    def connect(self) -> None:
+        try:
+            import IfxPy  # noqa: PLC0415
+            import IfxPyDbi  # noqa: PLC0415
+        except ImportError as exc:
+            raise ImportError(
+                "IfxPy and IfxPyDbi are required for Informix connections. "
+                "Install with: pip install IfxPy IfxPyDbi"
+            ) from exc
+
+        if self._conn is None:
+            conn_str = (
+                f"SERVER={self.server};"
+                f"DATABASE={self.database};"
+                f"HOST={self.host};"
+                f"SERVICE={self.port};"
+                f"UID={self.user};"
+                f"PWD={self.password};"
+                f"PROTOCOL=onsoctcp;"
+                f"ConnectTimeout={self.connect_timeout};"
+            )
+            if self.logger:
+                self.logger.info(
+                    "Connecting to Informix %s:%s/%s (server=%s)",
+                    self.host,
+                    self.port,
+                    self.database,
+                    self.server,
+                )
+            raw_conn = IfxPy.connect(conn_str, "", "")
+            self._conn = IfxPyDbi.Connection(raw_conn)
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+            if self.logger:
+                self.logger.info("Connection closed: %s/%s", self.host, self.database)
+
+    @staticmethod
+    def _row_to_dict(cursor, row) -> dict:
+        """Convert row tuple to dictionary with lowercase column names."""
+        return {desc[0].lower(): val for desc, val in zip(cursor.description, row)}
+
+    def fetch_all(self, sql: str, params=None) -> list[dict]:
+        start = time.perf_counter()
+        self._ensure_connected()
+        cur = self._conn.cursor()
+        cur.execute(sql, params or ())
+        rows = [self._row_to_dict(cur, r) for r in cur.fetchall()]
+        cur.close()
+        elapsed_ms = (time.perf_counter() - start) * 1000
+        if self.logger:
+            self.logger.info(
+                "fetch_all returned %s rows in %.1fms | %s",
+                len(rows),
+                elapsed_ms,
+                sql[:120],
+            )
+        return rows
+
+    def fetch_one(self, sql: str, params=None) -> dict | None:
+        self._ensure_connected()
+        cur = self._conn.cursor()
+        cur.execute(sql, params or ())
+        row = cur.fetchone()
+        result = self._row_to_dict(cur, row) if row else None
+        cur.close()
+        return result
+
+    def fetch_scalar(self, sql: str, params=None) -> Any:
+        self._ensure_connected()
+        cur = self._conn.cursor()
+        cur.execute(sql, params or ())
+        row = cur.fetchone()
+        cur.close()
+        return row[0] if row else None
+
+    def table_exists(self, table: str, schema: str = "") -> bool:
+        """
+        Check if a table exists in the database.
+
+        Args:
+            table: Table name
+            schema: Schema/owner name (default: current user)
+
+        Returns:
+            True if table exists, False otherwise
+        """
+        schema_name = schema or self.user
+        sql = """
+            SELECT COUNT(*)
+            FROM systables
+            WHERE tabname = ?
+            AND owner = ?
+            AND tabtype = 'T'
+        """
+        return bool(self.fetch_scalar(sql, (table.lower(), schema_name.lower())))
+
+    def get_column_names(self, table: str, schema: str = "") -> list[str]:
+        """
+        Get column names for a table in order.
+
+        Args:
+            table: Table name
+            schema: Schema/owner name (default: current user)
+
+        Returns:
+            List of column names in lowercase
+        """
+        schema_name = schema or self.user
+        sql = """
+            SELECT c.colname
+            FROM syscolumns c
+            JOIN systables t ON c.tabid = t.tabid
+            WHERE t.tabname = ?
+            AND t.owner = ?
+            AND t.tabtype = 'T'
+            ORDER BY c.colno
+        """
+        rows = self.fetch_all(sql, (table.lower(), schema_name.lower()))
+        return [r["colname"].lower() for r in rows]
+
+    def _open_cursor(self):
+        self._ensure_connected()
+        return self._conn.cursor()
+
+    def _rows_to_dicts(self, cursor, rows: list) -> list[dict]:
+        return [self._row_to_dict(cursor, row) for row in rows]
+
+    def _ensure_connected(self) -> None:
+        if self._conn is None:
+            self.connect()

{pyplaykit-1.7.0 → pyplaykit-1.8.0}/utils/db_factory.py

@@ -7,6 +7,7 @@ Supported values for ``db_type`` (case-insensitive):
   sqlserver   — pyodbc + ODBC Driver 17/18 on the OS
   db2         — ibm_db + ibm_db_dbi
   oracle      — oracledb
+  informix    — IfxPy + IfxPyDbi
   snowflake   — snowflake-connector-python
 
 Each driver lazily imports its library inside ``connect()``, so uninstalled
@@ -17,7 +18,7 @@ from __future__ import annotations
 
 from utils.db_client import BaseDbClient
 
-_SUPPORTED = {"postgresql", "sqlite", "mysql", "sqlserver", "db2", "oracle", "snowflake"}
+_SUPPORTED = {"postgresql", "sqlite", "mysql", "sqlserver", "db2", "oracle", "informix", "snowflake"}
 
 
 class DbClientFactory:
@@ -122,6 +123,19 @@ class DbClientFactory:
                 logger=logger,
             )
 
+        if dt == "informix":
+            from utils.db_drivers.informix import InformixClient
+            return InformixClient(
+                host=kwargs["host"],
+                port=int(kwargs.get("port", 9088)),
+                database=kwargs.get("database", ""),
+                server=kwargs.get("server", ""),
+                user=kwargs.get("user", ""),
+                password=kwargs.get("password", ""),
+                connect_timeout=timeout,
+                logger=logger,
+            )
+
         # dt == "snowflake"
         from utils.db_drivers.snowflake import SnowflakeClient
         return SnowflakeClient(