altimate-engine 0.1.0__tar.gz

altimate_engine-0.1.0/.gitignore

@@ -0,0 +1,36 @@
+# Dependencies
+node_modules/
+.venv/
+
+# Build artifacts
+.turbo/
+dist/
+*.tsbuildinfo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment
+.env
+.env.local
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+
+# SQLite databases (feedback store creates these at runtime)
+*.db
+
+# Large intermediate files at repo root (generated during benchmark runs)
+/queries.json
+/queries_1k.json
+/results/

altimate_engine-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: altimate-engine
+Version: 0.1.0
+Summary: Python engine for Altimate Code — SQL analysis, lineage, dbt integration
+Project-URL: Homepage, https://github.com/AltimateAI/altimate-code
+Project-URL: Documentation, https://altimate-code.sh
+Project-URL: Repository, https://github.com/AltimateAI/altimate-code
+Project-URL: Issues, https://github.com/AltimateAI/altimate-code/issues
+Author-email: Altimate Inc <info@altimate.ai>
+License-Expression: MIT
+Keywords: bigquery,data-engineering,dbt,lineage,snowflake,sql
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: duckdb>=0.9; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: docker
+Requires-Dist: docker>=7.0; extra == 'docker'
+Provides-Extra: security
+Requires-Dist: keyring>=24.0; extra == 'security'
+Provides-Extra: tunneling
+Requires-Dist: paramiko>=3.0; extra == 'tunneling'
+Requires-Dist: sshtunnel>=0.4; extra == 'tunneling'
+Provides-Extra: warehouses
+Requires-Dist: boto3>=1.28; extra == 'warehouses'
+Requires-Dist: cryptography>=41.0; extra == 'warehouses'
+Requires-Dist: databricks-sql-connector>=3.0; extra == 'warehouses'
+Requires-Dist: duckdb>=0.9; extra == 'warehouses'
+Requires-Dist: google-cloud-bigquery>=3.0; extra == 'warehouses'
+Requires-Dist: mysql-connector-python>=8.0; extra == 'warehouses'
+Requires-Dist: psycopg2-binary>=2.9; extra == 'warehouses'
+Requires-Dist: pyodbc>=5.0; extra == 'warehouses'
+Requires-Dist: snowflake-connector-python>=3.0; extra == 'warehouses'
+Description-Content-Type: text/markdown
+
+# altimate-engine
+
+Python engine for [Altimate Code](https://github.com/AltimateAI/altimate-code) — SQL analysis, column-level lineage, and dbt integration.
+
+## Installation
+
+```
+pip install altimate-engine
+```
+
+For warehouse connectivity (Snowflake, BigQuery, Databricks, etc.):
+
+```
+pip install altimate-engine[warehouses]
+```
+
+## Usage
+
+This package is designed to be used as a sidecar process for the Altimate Code CLI. It communicates via JSON-RPC over stdio.
+
+```python
+python -m altimate_engine.server
+```
+
+## Documentation
+
+See the main repository for full documentation: https://github.com/AltimateAI/altimate-code
+
+## License
+
+MIT

altimate_engine-0.1.0/README.md

@@ -0,0 +1,31 @@
+# altimate-engine
+
+Python engine for [Altimate Code](https://github.com/AltimateAI/altimate-code) — SQL analysis, column-level lineage, and dbt integration.
+
+## Installation
+
+```
+pip install altimate-engine
+```
+
+For warehouse connectivity (Snowflake, BigQuery, Databricks, etc.):
+
+```
+pip install altimate-engine[warehouses]
+```
+
+## Usage
+
+This package is designed to be used as a sidecar process for the Altimate Code CLI. It communicates via JSON-RPC over stdio.
+
+```python
+python -m altimate_engine.server
+```
+
+## Documentation
+
+See the main repository for full documentation: https://github.com/AltimateAI/altimate-code
+
+## License
+
+MIT

altimate_engine-0.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "altimate-engine"
+version = "0.1.0"
+description = "Python engine for Altimate Code — SQL analysis, lineage, dbt integration"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Altimate Inc", email = "info@altimate.ai" },
+]
+keywords = ["sql", "dbt", "data-engineering", "lineage", "snowflake", "bigquery"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "pydantic>=2.0",
+    "pyyaml>=6.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AltimateAI/altimate-code"
+Documentation = "https://altimate-code.sh"
+Repository = "https://github.com/AltimateAI/altimate-code"
+Issues = "https://github.com/AltimateAI/altimate-code/issues"
+
+[project.optional-dependencies]
+warehouses = [
+    "psycopg2-binary>=2.9",
+    "snowflake-connector-python>=3.0",
+    "duckdb>=0.9",
+    "cryptography>=41.0",
+    "google-cloud-bigquery>=3.0",
+    "databricks-sql-connector>=3.0",
+    "boto3>=1.28",
+    "mysql-connector-python>=8.0",
+    "pyodbc>=5.0",
+]
+security = ["keyring>=24.0"]
+docker = ["docker>=7.0"]
+tunneling = ["sshtunnel>=0.4", "paramiko>=3.0"]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.4",
+    "duckdb>=0.9",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/altimate_engine"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120

altimate_engine-0.1.0/src/altimate_engine/__init__.py

@@ -0,0 +1,3 @@
+"""Altimate Engine — Python sidecar for the Altimate Code CLI."""
+
+__version__ = "0.1.0"

altimate_engine-0.1.0/src/altimate_engine/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for `python -m altimate_engine`."""
+
+from altimate_engine.server import main
+
+main()

altimate_engine-0.1.0/src/altimate_engine/ci/cost_gate.py

@@ -0,0 +1,162 @@
+"""CI cost gate — scan changed SQL files for critical issues.
+
+Reads SQL files, runs lint analysis, and returns
+pass/fail based on whether CRITICAL severity issues are found.
+
+Skips:
+  - Jinja templates ({{ }}, {% %})
+  - Parse errors (likely Jinja or non-standard SQL)
+  - Non-SQL files
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Any
+
+from altimate_engine.sql.guard import guard_lint
+
+
+# Jinja pattern: {{ ... }} or {% ... %} or {# ... #}
+_JINJA_PATTERN = re.compile(r"\{\{.*?\}\}|\{%.*?%\}|\{#.*?#\}", re.DOTALL)
+
+
+def _has_jinja(sql: str) -> bool:
+    """Check if SQL contains Jinja template syntax."""
+    return bool(_JINJA_PATTERN.search(sql))
+
+
+def _split_statements(sql: str) -> list[str]:
+    """Split SQL on semicolons, filtering empty statements."""
+    statements = []
+    for stmt in sql.split(";"):
+        stmt = stmt.strip()
+        if stmt:
+            statements.append(stmt)
+    return statements
+
+
+def scan_files(
+    file_paths: list[str],
+    dialect: str = "snowflake",
+) -> dict[str, Any]:
+    """Scan SQL files for critical issues.
+
+    Args:
+        file_paths: List of SQL file paths to scan.
+        dialect: SQL dialect for analysis (default: snowflake).
+
+    Returns:
+        Dict with pass/fail status, per-file results, and summary.
+    """
+    file_results: list[dict[str, Any]] = []
+    total_issues = 0
+    critical_count = 0
+    files_scanned = 0
+    files_skipped = 0
+
+    for path in file_paths:
+        # Skip non-SQL files
+        if not path.endswith(".sql"):
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "not a SQL file",
+                "issues": [],
+            })
+            continue
+
+        # Read file
+        if not os.path.isfile(path):
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "file not found",
+                "issues": [],
+            })
+            continue
+
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
+        except Exception as e:
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": f"read error: {e}",
+                "issues": [],
+            })
+            continue
+
+        # Skip Jinja templates
+        if _has_jinja(content):
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "contains Jinja templates",
+                "issues": [],
+            })
+            continue
+
+        # Split and analyze each statement
+        statements = _split_statements(content)
+        if not statements:
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "empty file",
+                "issues": [],
+            })
+            continue
+
+        files_scanned += 1
+        file_issues: list[dict[str, Any]] = []
+
+        for stmt in statements:
+            # Run lint analysis
+            lint_result = guard_lint(stmt)
+            if lint_result.get("error"):
+                # Parse error — skip this statement (likely incomplete SQL)
+                continue
+
+            for finding in lint_result.get("findings", lint_result.get("issues", [])):
+                severity = finding.get("severity", "warning")
+                file_issues.append({
+                    "type": finding.get("rule", finding.get("type", "UNKNOWN")),
+                    "severity": severity,
+                    "message": finding.get("message", ""),
+                    "source": "lint",
+                })
+                total_issues += 1
+                if severity in ("error", "critical"):
+                    critical_count += 1
+
+        status = "fail" if any(
+            i["severity"] in ("error", "critical") for i in file_issues
+        ) else "pass"
+
+        file_results.append({
+            "file": path,
+            "status": status,
+            "issues": file_issues,
+        })
+
+    passed = critical_count == 0
+
+    return {
+        "success": True,
+        "passed": passed,
+        "exit_code": 0 if passed else 1,
+        "files_scanned": files_scanned,
+        "files_skipped": files_skipped,
+        "total_issues": total_issues,
+        "critical_count": critical_count,
+        "file_results": file_results,
+        "error": None,
+    }

altimate_engine-0.1.0/src/altimate_engine/connections.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from altimate_engine.connectors.base import Connector
+from altimate_engine.credential_store import resolve_config
+from altimate_engine.ssh_tunnel import start, stop
+
+SSH_FIELDS = {
+    "ssh_host",
+    "ssh_port",
+    "ssh_user",
+    "ssh_auth_type",
+    "ssh_key_path",
+    "ssh_password",
+}
+
+
+class ConnectionRegistry:
+    _connections: dict[str, dict[str, Any]] = {}
+    _loaded: bool = False
+
+    @classmethod
+    def load(cls) -> None:
+        if cls._loaded:
+            return
+
+        global_config = Path.home() / ".altimate-code" / "connections.json"
+        if global_config.exists():
+            with open(global_config) as f:
+                cls._connections.update(json.load(f))
+
+        project_config = Path.cwd() / ".altimate-code" / "connections.json"
+        if project_config.exists():
+            with open(project_config) as f:
+                cls._connections.update(json.load(f))
+
+        for key, value in os.environ.items():
+            if key.startswith("ALTIMATE_CODE_CONN_"):
+                name = key[len("ALTIMATE_CODE_CONN_") :].lower()
+                try:
+                    cls._connections[name] = json.loads(value)
+                except json.JSONDecodeError:
+                    pass
+
+        cls._loaded = True
+
+    @classmethod
+    def get(cls, name: str) -> Connector:
+        cls.load()
+
+        if name not in cls._connections:
+            raise ValueError(f"Connection '{name}' not found in registry")
+
+        config = dict(cls._connections[name])
+        config = resolve_config(name, config)
+
+        ssh_host = config.get("ssh_host")
+        if ssh_host:
+            if config.get("connection_string"):
+                raise ValueError(
+                    "SSH tunneling requires explicit host/port — "
+                    "cannot be used with connection_string"
+                )
+            ssh_config = {
+                k: config.pop(k) for k in list(config.keys()) if k in SSH_FIELDS
+            }
+            local_port = start(
+                name=name,
+                ssh_host=ssh_config.get("ssh_host", ""),
+                remote_host=config.get("host", "localhost"),
+                remote_port=config.get("port", 5432),
+                ssh_port=ssh_config.get("ssh_port", 22),
+                ssh_user=ssh_config.get("ssh_user"),
+                ssh_auth_type=ssh_config.get("ssh_auth_type", "key"),
+                ssh_key_path=ssh_config.get("ssh_key_path"),
+                ssh_password=ssh_config.get("ssh_password"),
+            )
+            config["host"] = "127.0.0.1"
+            config["port"] = local_port
+
+        dialect = config.get("type", "duckdb")
+
+        if dialect == "duckdb":
+            from altimate_engine.connectors.duckdb import DuckDBConnector
+
+            return DuckDBConnector(
+                path=config.get("path", ":memory:"),
+                **{k: v for k, v in config.items() if k not in ("type", "path")},
+            )
+        elif dialect == "postgres":
+            from altimate_engine.connectors.postgres import PostgresConnector
+
+            return PostgresConnector(
+                connection_string=config.get("connection_string", ""),
+                **{
+                    k: v
+                    for k, v in config.items()
+                    if k not in ("type", "connection_string")
+                },
+            )
+        elif dialect == "snowflake":
+            from altimate_engine.connectors.snowflake import SnowflakeConnector
+
+            _snowflake_keys = {
+                "type",
+                "account",
+                "user",
+                "password",
+                "private_key_path",
+                "private_key_passphrase",
+                "warehouse",
+                "database",
+                "schema",
+                "role",
+            }
+            return SnowflakeConnector(
+                account=config.get("account", ""),
+                user=config.get("user", ""),
+                password=config.get("password"),
+                private_key_path=config.get("private_key_path"),
+                private_key_passphrase=config.get("private_key_passphrase"),
+                warehouse=config.get("warehouse"),
+                database=config.get("database"),
+                schema=config.get("schema"),
+                role=config.get("role"),
+                **{k: v for k, v in config.items() if k not in _snowflake_keys},
+            )
+        elif dialect == "bigquery":
+            from altimate_engine.connectors.bigquery import BigQueryConnector
+
+            _bigquery_keys = {"type", "project", "credentials_path", "location"}
+            return BigQueryConnector(
+                project=config.get("project", ""),
+                credentials_path=config.get("credentials_path"),
+                location=config.get("location", "US"),
+                **{k: v for k, v in config.items() if k not in _bigquery_keys},
+            )
+        elif dialect == "databricks":
+            from altimate_engine.connectors.databricks import DatabricksConnector
+
+            _databricks_keys = {
+                "type",
+                "server_hostname",
+                "http_path",
+                "access_token",
+                "catalog",
+                "schema",
+            }
+            return DatabricksConnector(
+                server_hostname=config.get("server_hostname", ""),
+                http_path=config.get("http_path", ""),
+                access_token=config.get("access_token"),
+                catalog=config.get("catalog"),
+                schema=config.get("schema"),
+                **{k: v for k, v in config.items() if k not in _databricks_keys},
+            )
+        elif dialect == "redshift":
+            from altimate_engine.connectors.redshift import RedshiftConnector
+
+            _redshift_keys = {
+                "type",
+                "host",
+                "port",
+                "database",
+                "user",
+                "password",
+                "connection_string",
+                "iam_role",
+                "region",
+                "cluster_identifier",
+            }
+            return RedshiftConnector(
+                host=config.get("host", ""),
+                port=config.get("port", 5439),
+                database=config.get("database", "dev"),
+                user=config.get("user"),
+                password=config.get("password"),
+                connection_string=config.get("connection_string"),
+                iam_role=config.get("iam_role"),
+                region=config.get("region"),
+                cluster_identifier=config.get("cluster_identifier"),
+                **{k: v for k, v in config.items() if k not in _redshift_keys},
+            )
+        elif dialect == "mysql":
+            from altimate_engine.connectors.mysql import MySQLConnector
+
+            _mysql_keys = {
+                "type",
+                "host",
+                "port",
+                "database",
+                "user",
+                "password",
+                "ssl_ca",
+                "ssl_cert",
+                "ssl_key",
+            }
+            return MySQLConnector(
+                host=config.get("host", "localhost"),
+                port=config.get("port", 3306),
+                database=config.get("database"),
+                user=config.get("user"),
+                password=config.get("password"),
+                ssl_ca=config.get("ssl_ca"),
+                ssl_cert=config.get("ssl_cert"),
+                ssl_key=config.get("ssl_key"),
+                **{k: v for k, v in config.items() if k not in _mysql_keys},
+            )
+        elif dialect == "sqlserver":
+            from altimate_engine.connectors.sqlserver import SQLServerConnector
+
+            _sqlserver_keys = {
+                "type",
+                "host",
+                "port",
+                "database",
+                "user",
+                "password",
+                "driver",
+                "azure_auth",
+                "trust_server_certificate",
+            }
+            return SQLServerConnector(
+                host=config.get("host", "localhost"),
+                port=config.get("port", 1433),
+                database=config.get("database"),
+                user=config.get("user"),
+                password=config.get("password"),
+                driver=config.get("driver", "ODBC Driver 18 for SQL Server"),
+                azure_auth=config.get("azure_auth", False),
+                trust_server_certificate=config.get("trust_server_certificate", False),
+                **{k: v for k, v in config.items() if k not in _sqlserver_keys},
+            )
+        else:
+            raise ValueError(f"Unsupported connector type: {dialect}")
+
+    @classmethod
+    def list(cls) -> list[dict[str, Any]]:
+        cls.load()
+        return [
+            {"name": name, "type": config.get("type", "unknown")}
+            for name, config in cls._connections.items()
+        ]
+
+    @classmethod
+    def test(cls, name: str) -> dict[str, Any]:
+        try:
+            connector = cls.get(name)
+            connector.connect()
+            connector.execute("SELECT 1")
+            connector.close()
+            return {"connected": True, "error": None}
+        except Exception as e:
+            return {"connected": False, "error": str(e)}
+        finally:
+            stop(name)
+
+    @classmethod
+    def add(cls, name: str, config: dict[str, Any]) -> dict[str, Any]:
+        from altimate_engine.credential_store import save_connection
+
+        result = save_connection(name, config)
+        cls._loaded = False
+        return result
+
+    @classmethod
+    def remove(cls, name: str) -> bool:
+        from altimate_engine.credential_store import remove_connection
+
+        result = remove_connection(name)
+        cls._loaded = False
+        return result
+
+    @classmethod
+    def reload(cls) -> None:
+        cls._loaded = False
+        cls._connections.clear()

altimate_engine-0.1.0/src/altimate_engine/connectors/__init__.py

@@ -0,0 +1,21 @@
+from altimate_engine.connectors.base import Connector
+from altimate_engine.connectors.duckdb import DuckDBConnector
+from altimate_engine.connectors.postgres import PostgresConnector
+from altimate_engine.connectors.snowflake import SnowflakeConnector
+from altimate_engine.connectors.bigquery import BigQueryConnector
+from altimate_engine.connectors.databricks import DatabricksConnector
+from altimate_engine.connectors.redshift import RedshiftConnector
+from altimate_engine.connectors.mysql import MySQLConnector
+from altimate_engine.connectors.sqlserver import SQLServerConnector
+
+__all__ = [
+    "Connector",
+    "DuckDBConnector",
+    "PostgresConnector",
+    "SnowflakeConnector",
+    "BigQueryConnector",
+    "DatabricksConnector",
+    "RedshiftConnector",
+    "MySQLConnector",
+    "SQLServerConnector",
+]