pyplaykit 1.7.0__tar.gz → 1.7.1__tar.gz

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

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

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

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

{pyplaykit-1.7.0 → pyplaykit-1.7.1}/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

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

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

pyplaykit-1.7.1/utils/database_clients.py

@@ -0,0 +1,310 @@
+"""
+Custom database client wrappers for cross-database comparisons.
+
+PyPlayKit's built-in db_client fixture supports PostgreSQL only.
+Use these wrappers to compare other database types:
+- Oracle
+- SQL Server
+- MySQL
+
+Installation:
+    pip install cx_Oracle      # Oracle
+    pip install pyodbc          # SQL Server
+    pip install pymysql         # MySQL
+
+Usage:
+    from utils.database_clients import OracleClient, SQLServerClient, MySQLClient
+
+    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 MySQLClient(DatabaseClient):
+    """
+    MySQL database client wrapper.
+
+    Installation:
+        pip install pymysql
+
+    Usage:
+        mysql = MySQLClient(
+            host="mysql.example.com",
+            user="root",
+            password="password",
+            database="myapp"
+        )
+
+        results = mysql.fetch_all("SELECT * FROM products")
+        mysql.close()
+
+    Column Names:
+        Returns lowercase column names by default (MySQL convention).
+    """
+
+    def __init__(
+        self,
+        host: str,
+        user: str,
+        password: str,
+        database: str,
+        port: int = 3306,
+        charset: str = "utf8mb4"
+    ):
+        """
+        Initialize MySQL connection.
+
+        Args:
+            host: MySQL hostname
+            user: MySQL username
+            password: MySQL password
+            database: Database name
+            port: MySQL port (default: 3306)
+            charset: Character set (default: utf8mb4)
+        """
+        try:
+            import pymysql
+        except ImportError:
+            raise ImportError(
+                "pymysql is required for MySQL connections. "
+                "Install with: pip install pymysql"
+            )
+
+        self.connection = pymysql.connect(
+            host=host,
+            port=port,
+            user=user,
+            password=password,
+            database=database,
+            charset=charset,
+            cursorclass=pymysql.cursors.DictCursor  # Returns dict automatically
+        )
+
+    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)
+
+        # pymysql DictCursor already returns list of dicts
+        result = cursor.fetchall()
+
+        cursor.close()
+        return result
+
+    def close(self):
+        """Close MySQL 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
+
+MySQLClient.__enter__ = lambda self: self
+MySQLClient.__exit__ = lambda self, *args: self.close() or False