mockit-sql-engine 0.1.0__tar.gz

mockit_sql_engine-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: mockit-sql-engine
+Version: 0.1.0
+Summary: A lightweight CLI to mock DB schemas locally
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: faker>=19.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: psycopg2-binary
+
+# MockIt 🚀
+
+[![PyPI version](https://img.shields.io/pypi/v/mockit.svg)](https://pypi.org/project/mockit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Replicate cloud database schemas locally with high-fidelity synthetic data.**
+
+MockIt is a CLI-first developer tool designed for Data Engineers who want to escape the high costs and latency of testing against production cloud warehouses like AWS Redshift or Snowflake.
+
+---
+
+## 🌟 Key Features
+
+* **Schema Reflection**: Automatically inspects source tables and clones their structure (columns, types, nullability) to a local target.
+* **Smart Type Mapping**: Intelligently maps SQL types to relevant `Faker` providers (e.g., `JSON` columns get JSON objects, `VARCHAR(email)` gets realistic email addresses).
+* **Constraint Stripping**: Automatically removes Foreign Key constraints during local replication to allow for isolated table testing.
+* **Identity Management**: Handles `SERIAL` and `IDENTITY` columns by skipping manual inserts, allowing the local database to manage primary keys.
+* **Transaction Safety**: Built on SQLAlchemy 2.0 for robust, atomic data injections.
+
+---
+
+## 🚀 Installation
+
+Install MockIt via pip:
+
+```bash
+pip install mockit

mockit_sql_engine-0.1.0/README.md

@@ -0,0 +1,27 @@
+# MockIt 🚀
+
+[![PyPI version](https://img.shields.io/pypi/v/mockit.svg)](https://pypi.org/project/mockit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Replicate cloud database schemas locally with high-fidelity synthetic data.**
+
+MockIt is a CLI-first developer tool designed for Data Engineers who want to escape the high costs and latency of testing against production cloud warehouses like AWS Redshift or Snowflake.
+
+---
+
+## 🌟 Key Features
+
+* **Schema Reflection**: Automatically inspects source tables and clones their structure (columns, types, nullability) to a local target.
+* **Smart Type Mapping**: Intelligently maps SQL types to relevant `Faker` providers (e.g., `JSON` columns get JSON objects, `VARCHAR(email)` gets realistic email addresses).
+* **Constraint Stripping**: Automatically removes Foreign Key constraints during local replication to allow for isolated table testing.
+* **Identity Management**: Handles `SERIAL` and `IDENTITY` columns by skipping manual inserts, allowing the local database to manage primary keys.
+* **Transaction Safety**: Built on SQLAlchemy 2.0 for robust, atomic data injections.
+
+---
+
+## 🚀 Installation
+
+Install MockIt via pip:
+
+```bash
+pip install mockit

mockit_sql_engine-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mockit-sql-engine"
+version = "0.1.0"
+description = "A lightweight CLI to mock DB schemas locally"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "sqlalchemy>=2.0.0",
+    "faker>=19.0.0",
+    "click>=8.0.0",
+    "psycopg2-binary"
+]
+
+[project.scripts]
+mockit = "mockit.cli:main"

mockit_sql_engine-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mockit_sql_engine-0.1.0/src/mockit/cli.py

@@ -0,0 +1,46 @@
+import click
+import logging
+from .engine import mock_table
+
+# Disable extra SQLAlchemy logging unless the user wants --debug
+logging.basicConfig(level=logging.WARNING)
+
+@click.command()
+@click.option('--source', required=True, help='Source DB URI (e.g. Redshift/Prod)')
+@click.option('--target', required=True, help='Target DB URI (e.g. Local Postgres)')
+@click.option('--table', required=True, help='Table name (can be schema.table)')
+@click.option('--rows', default=10, type=int, help='Number of rows to generate')
+@click.option('--reset', is_flag=True, default=True, help='Wipe target table before inserting (True by default)')
+@click.option('--debug', is_flag=True, help='Show full stack trace on error')
+def main(source, target, table, rows, reset, debug):
+    """🚀 MockIt: Recreate prod schemas locally with fake data."""
+    
+    if debug:
+        logging.getLogger("mockit").setLevel(logging.INFO)
+
+    click.secho(f"🔍 Analyzing schema for {table}...", fg='cyan')
+    
+    try:
+        # We pass the 'reset' flag to the 'truncate' parameter in engine.py
+        mock_table(
+            source_uri=source, 
+            target_uri=target, 
+            table_name=table, 
+            row_count=rows, 
+            truncate=reset
+        )
+        
+        click.secho(f"✨ Success!", fg='green', bold=True)
+        click.echo(f"  - Table: {table}")
+        click.echo(f"  - Rows Created: {rows}")
+        click.echo(f"  - Reset Performed: {reset}")
+        
+    except Exception as e:
+        click.secho(f"❌ Error: {e}", fg='red', err=True)
+        if not debug:
+            click.echo("\n💡 Tip: Use --debug for a full stack trace or check your DB credentials.")
+        else:
+            raise e
+
+if __name__ == '__main__':
+    main()

mockit_sql_engine-0.1.0/src/mockit/engine.py

@@ -0,0 +1,124 @@
+import sqlalchemy as sa
+from sqlalchemy import create_engine, MetaData, Table, insert, text
+from sqlalchemy.engine import reflection
+from faker import Faker
+import random
+import logging
+
+# Setup professional logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("mockit")
+
+fake = Faker()
+
+def get_mock_value(column):
+    """
+    Advanced mapping of SQL types and column names to Faker providers.
+    Handles standard types, strings with length limits, and common names.
+    """
+    name = column.name.lower()
+    # Get the string representation of the type (e.g., 'INTEGER', 'VARCHAR(50)', 'JSONB')
+    ctype = str(column.type).upper()
+
+    # 1. Specialized Name-based Smarts (Highest Priority)
+    if "email" in name: return fake.email()
+    if "user" in name or "name" in name: return fake.name()
+    if "city" in name: return fake.city()
+    if "phone" in name: return fake.phone_number()
+    if "status" in name: return random.choice(['SUCCESS', 'FAILED', 'PENDING', 'ACTIVE'])
+    if "url" in name: return fake.url()
+    
+    # 2. Complex Type Handling (JSON/UUID)
+    if "JSON" in ctype:
+        return {"id": random.randint(1, 100), "mocked": True, "data": fake.word()}
+    if "UUID" in ctype:
+        return fake.uuid4()
+
+    # 3. Numeric Types
+    if "INT" in ctype:
+        return random.randint(1, 1000)
+    if any(x in ctype for x in ["NUMERIC", "DECIMAL", "FLOAT", "DOUBLE"]):
+        return round(random.uniform(10.0, 500.0), 2)
+    
+    # 4. Boolean
+    if "BOOL" in ctype:
+        return random.choice([True, False])
+    
+    # 5. Dates & Timestamps
+    if "DATE" in ctype or "TIME" in ctype:
+        return fake.date_time_this_year()
+    
+    # 6. String/Varchar with Length Protection
+    if "CHAR" in ctype or "TEXT" in ctype:
+        # Respect VARCHAR(N) limits if they exist to prevent 'value too long' errors
+        limit = getattr(column.type, 'length', None)
+        val = fake.word() if not limit or limit > 10 else fake.lexify("????")
+        return val[:limit] if limit else val
+    
+    # Final Fallback
+    return fake.word()
+
+def mock_table(source_uri, target_uri, table_name, row_count, truncate=True):
+    """
+    Enterprise-grade table mocking:
+    - Reflects source schema (Redshift/Postgres/etc)
+    - Replicates structure to local Target
+    - Strips constraints that cause local failures (FKs)
+    - Generates type-safe fake data
+    """
+    src_engine = create_engine(source_uri)
+    tgt_engine = create_engine(target_uri)
+    
+    schema = None
+    actual_table_name = table_name
+    if "." in table_name:
+        schema, actual_table_name = table_name.split(".")
+
+    try:
+        # 1. Reflect Source Blueprint
+        metadata_src = MetaData()
+        source_table = Table(actual_table_name, metadata_src, autoload_with=src_engine, schema=schema)
+        logger.info(f"Reflected source schema for {table_name}")
+
+        # 2. Build Local Target Blueprint
+        metadata_tgt = MetaData()
+        target_table = Table(actual_table_name, metadata_tgt, schema=schema)
+        
+        for col in source_table.columns:
+            new_col = col.copy()
+            # Disable unique constraints and clear Foreign Keys to allow isolated testing
+            new_col.unique = False
+            new_col.foreign_keys.clear()
+            target_table.append_column(new_col)
+
+        # 3. Create Table on Local Target if missing
+        metadata_tgt.create_all(tgt_engine)
+
+        # 4. Clean Slate (Truncate)
+        if truncate:
+            with tgt_engine.begin() as conn:
+                # Use RESTART IDENTITY to reset SERIAL counters to 1
+                full_name = f"{schema}.{actual_table_name}" if schema else actual_table_name
+                conn.execute(text(f"TRUNCATE TABLE {full_name} RESTART IDENTITY CASCADE;"))
+                logger.info(f"Table {full_name} truncated and identities reset.")
+
+        # 5. Generate Smart Mock Data
+        mock_rows = []
+        for _ in range(row_count):
+            row_data = {}
+            for col in target_table.columns:
+                # Skip Auto-increment columns; let Local Postgres generate IDs
+                if col.primary_key and col.autoincrement:
+                    continue
+                row_data[col.name] = get_mock_value(col)
+            mock_rows.append(row_data)
+
+        # 6. Bulk Insert into Local
+        with tgt_engine.begin() as conn:
+            conn.execute(insert(target_table), mock_rows)
+        
+        logger.info(f"✅ Successfully injected {row_count} mock rows into {table_name}")
+
+    except Exception as e:
+        logger.error(f"❌ Robust Mocking Failed: {str(e)}")
+        raise e

mockit_sql_engine-0.1.0/src/mockit_sql_engine.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: mockit-sql-engine
+Version: 0.1.0
+Summary: A lightweight CLI to mock DB schemas locally
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: faker>=19.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: psycopg2-binary
+
+# MockIt 🚀
+
+[![PyPI version](https://img.shields.io/pypi/v/mockit.svg)](https://pypi.org/project/mockit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Replicate cloud database schemas locally with high-fidelity synthetic data.**
+
+MockIt is a CLI-first developer tool designed for Data Engineers who want to escape the high costs and latency of testing against production cloud warehouses like AWS Redshift or Snowflake.
+
+---
+
+## 🌟 Key Features
+
+* **Schema Reflection**: Automatically inspects source tables and clones their structure (columns, types, nullability) to a local target.
+* **Smart Type Mapping**: Intelligently maps SQL types to relevant `Faker` providers (e.g., `JSON` columns get JSON objects, `VARCHAR(email)` gets realistic email addresses).
+* **Constraint Stripping**: Automatically removes Foreign Key constraints during local replication to allow for isolated table testing.
+* **Identity Management**: Handles `SERIAL` and `IDENTITY` columns by skipping manual inserts, allowing the local database to manage primary keys.
+* **Transaction Safety**: Built on SQLAlchemy 2.0 for robust, atomic data injections.
+
+---
+
+## 🚀 Installation
+
+Install MockIt via pip:
+
+```bash
+pip install mockit

mockit_sql_engine-0.1.0/src/mockit_sql_engine.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/mockit/__init__.py
+src/mockit/cli.py
+src/mockit/engine.py
+src/mockit_sql_engine.egg-info/PKG-INFO
+src/mockit_sql_engine.egg-info/SOURCES.txt
+src/mockit_sql_engine.egg-info/dependency_links.txt
+src/mockit_sql_engine.egg-info/entry_points.txt
+src/mockit_sql_engine.egg-info/requires.txt
+src/mockit_sql_engine.egg-info/top_level.txt

mockit_sql_engine-0.1.0/src/mockit_sql_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mockit_sql_engine-0.1.0/src/mockit_sql_engine.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mockit = mockit.cli:main

mockit_sql_engine-0.1.0/src/mockit_sql_engine.egg-info/requires.txt

@@ -0,0 +1,4 @@
+sqlalchemy>=2.0.0
+faker>=19.0.0
+click>=8.0.0
+psycopg2-binary

mockit_sql_engine-0.1.0/src/mockit_sql_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+mockit