detectkit 0.10.0__tar.gz → 0.11.0__tar.gz

{detectkit-0.10.0/detectkit.egg-info → detectkit-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.10.0
+Version: 0.11.0
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT
@@ -61,7 +61,9 @@ Requires-Dist: black>=23.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Provides-Extra: integration
-Requires-Dist: testcontainers[clickhouse]>=4.0; extra == "integration"
+Requires-Dist: testcontainers[clickhouse,mysql,postgres]>=4.0; extra == "integration"
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "integration"
+Requires-Dist: pymysql>=1.0.0; extra == "integration"
 Dynamic: license-file
 
 # detectkit

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/__init__.py

@@ -4,7 +4,7 @@ detectk - Anomaly Detection for Time-Series Metrics
 A Python library for data analysts and engineers to monitor metrics with automatic anomaly detection.
 """
 
-__version__ = "0.10.0"
+__version__ = "0.11.0"
 
 from detectkit.core.interval import Interval
 from detectkit.core.models import ColumnDefinition, TableModel

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/cli/assets/claude/rules/overview.md

@@ -3,9 +3,9 @@
 detectkit is a Python library and CLI (`dtk`) for monitoring time-series
 metrics with automatic anomaly detection and multi-channel alerting. It is
 **dbt-like**: metrics live as YAML + SQL in a project directory, and you run
-them with one command. Core logic is pure numpy (no pandas). **ClickHouse is
-the only implemented backend today**; PostgreSQL and MySQL are planned (their
-profiles validate but creating a manager raises `NotImplementedError`).
+them with one command. Core logic is pure numpy (no pandas). **ClickHouse,
+PostgreSQL and MySQL are all fully supported** — only the connection and the SQL
+dialect of your metric queries differ between them.
 
 ## The pipeline: load → detect → alert
 

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/cli/assets/claude/rules/project.md

@@ -78,11 +78,11 @@ alert_channels:
 
 ### Database profiles
 
-> ClickHouse is the only implemented backend today. PostgreSQL and MySQL are
-> planned — their profiles validate, but creating a manager raises
-> `NotImplementedError("... coming soon")`.
+> ClickHouse, PostgreSQL and MySQL are all fully supported. ClickHouse/MySQL use
+> two *databases*; PostgreSQL connects to one `database` and uses two *schemas*.
+> `dtk init --db-type {clickhouse,postgres,mysql}` scaffolds the right shape.
 
-**ClickHouse** (priority backend):
+**ClickHouse**:
 ```yaml
 profiles:
   prod:
@@ -98,36 +98,34 @@ profiles:
       max_memory_usage: 10000000000
 ```
 
-**PostgreSQL** (planned, not yet implemented):
+**PostgreSQL** (connect to `database`, tables in schemas):
 ```yaml
 profiles:
   prod:
     type: postgres
     host: localhost
     port: 5432
-    database: analytics            # required
+    database: detectkit            # required — must already exist
     user: postgres
     password: "..."
-    internal_schema: detectkit     # required — _dtk_* tables
+    internal_schema: detectkit     # required — _dtk_* tables (auto-created)
     data_schema: public            # required — data queries
-    pool_size: 5                   # optional
-    max_overflow: 10               # optional
+    settings: {}                   # optional — extra psycopg2.connect kwargs
 ```
 
-**MySQL** (planned, not yet implemented):
+**MySQL** (8.0+; two databases):
 ```yaml
 profiles:
   prod:
     type: mysql
     host: localhost
     port: 3306
-    database: analytics            # required
     user: root
     password: "..."
-    internal_database: detectkit   # required
+    internal_database: detectkit   # required — _dtk_* tables (auto-created)
     data_database: analytics       # required
-    charset: utf8mb4               # optional
-    autocommit: true               # optional
+    database: analytics            # optional — default db for the connection
+    settings: {}                   # optional — extra pymysql.connect kwargs
 ```
 
 ### Alert channels
@@ -185,12 +183,12 @@ alert_channels:
 ## Notes
 
 - **First-run setup:** the `profiles.yml` that `dtk init` writes is a
-  placeholder — its `dev` profile points `internal_database` / `data_database`
-  at example values (`detectkit` / `default`) on `localhost`. Edit the host,
-  credentials and both database names to match your environment before running
-  (the **`dtk-setup-project`** skill walks this). There is no `database:` field —
-  ClickHouse needs both `internal_database` and `data_database`, or the run
-  raises `internal_database must be set for ClickHouse`.
+  placeholder scaffolded for `--db-type` (default ClickHouse) — its `dev`
+  profile points the location fields at example values on `localhost`. Edit the
+  host, credentials and location names to match your environment before running
+  (the **`dtk-setup-project`** skill walks this). ClickHouse/MySQL use
+  `internal_database` / `data_database` (no `database:` field on ClickHouse);
+  PostgreSQL connects to a `database` and uses `internal_schema` / `data_schema`.
 - `dtk run` (without `--profile`) uses the `default_profile` declared in
   **`profiles.yml`**; the `default_profile` in `detectkit_project.yml` is not
   read at runtime — keep them in sync to avoid confusion.

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/cli/assets/claude/skills/dtk-setup-project/SKILL.md

@@ -40,12 +40,17 @@ side by side, ask which one to set up.
 
 ## Step 1 — Pick the database backend
 
-**ClickHouse is the only implemented backend today.** PostgreSQL and MySQL
-profiles validate, but `dtk run` raises `NotImplementedError("PostgreSQL
-support coming soon")` / `"MySQL support coming soon"` when it builds the
-manager. If the user wants Postgres/MySQL, say plainly that runs won't work
-yet; you can still write the profile shape for later, but set expectations.
-Assume ClickHouse unless told otherwise.
+**ClickHouse, PostgreSQL and MySQL are all fully supported.** Ask which one the
+project uses (default to ClickHouse if unsure). `dtk init --db-type
+{clickhouse,postgres,mysql}` scaffolds `profiles.yml` for the chosen backend.
+The location fields differ:
+- **ClickHouse** / **MySQL** — two *databases*: `internal_database` / `data_database`.
+- **PostgreSQL** — connect to a `database` (must already exist), then two
+  *schemas*: `internal_schema` / `data_schema`.
+
+The metric query SQL dialect also differs (e.g. `toStartOfInterval` on
+ClickHouse vs `date_trunc`/`to_timestamp` on Postgres vs `FROM_UNIXTIME` on
+MySQL). Everything else — detectors, alerting, the CLI — is identical.
 
 ## Step 2 — Connection details (gather, don't guess)
 
@@ -74,8 +79,8 @@ values):
   data, e.g. `detectkit` or `monitoring`.
 - `data_database` — where the source tables your metric queries read from live.
 
-For Postgres these are `internal_schema` / `data_schema`; for MySQL they are
-`internal_database` / `data_database` (relevant only once those backends land).
+For Postgres these are `internal_schema` / `data_schema` (inside the connected
+`database`); for MySQL they are `internal_database` / `data_database`.
 
 ## Step 4 — Profile name & `default_profile`
 

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/cli/commands/init.py

@@ -8,93 +8,9 @@ from pathlib import Path
 
 import click
 
-
-def run_init(project_name: str, target_dir: str):
-    """
-    Initialize a new detectkit project.
-
-    Args:
-        project_name: Name of the project (or path - will extract basename)
-        target_dir: Directory to create project in
-
-    Creates:
-        project_name/
-        ├── detectkit_project.yml
-        ├── profiles.yml
-        ├── metrics/
-        │   └── .gitkeep
-        └── sql/
-            └── .gitkeep
-    """
-    # Extract just the directory name in case user passes a full path
-    project_name_clean = Path(project_name).name
-    target_path = Path(target_dir) / project_name_clean
-
-    # Check if project already exists
-    if target_path.exists():
-        click.echo(
-            click.style(
-                f"Error: Directory '{target_path}' already exists!",
-                fg="red",
-                bold=True,
-            )
-        )
-        return
-
-    # Create project directory
-    click.echo(f"Creating detectkit project '{project_name_clean}' in {target_dir}...")
-
-    target_path.mkdir(parents=True, exist_ok=True)
-
-    # Create subdirectories
-    (target_path / "metrics").mkdir(exist_ok=True)
-    (target_path / "sql").mkdir(exist_ok=True)
-
-    # Create .gitkeep files
-    (target_path / "metrics" / ".gitkeep").touch()
-    (target_path / "sql" / ".gitkeep").touch()
-
-    # Create detectkit_project.yml
-    project_config = f"""# detectkit project configuration
-name: {project_name_clean}
-version: '1.0'
-
-# Directory paths. These are the real config keys (nested under `paths:`);
-# a flat `metrics_path:` / `sql_path:` is not a recognized field and is ignored.
-paths:
-  metrics: metrics
-  sql: sql
-  templates: templates
-
-# Default profile to use (must exist in profiles.yml)
-default_profile: dev
-
-# Default table names (can be overridden in metrics)
-tables:
-  datapoints: _dtk_datapoints
-  detections: _dtk_detections
-  tasks: _dtk_tasks
-
-# Default timeouts (seconds)
-timeouts:
-  load: 1800      # 30 minutes
-  detect: 3600    # 1 hour
-  alert: 300      # 5 minutes
-"""
-
-    (target_path / "detectkit_project.yml").write_text(project_config)
-
-    # Create profiles.yml (must validate against ProfilesConfig: connections
-    # live under a top-level 'profiles:' mapping). ClickHouse needs BOTH
-    # `internal_database` (for the _dtk_* tables) and `data_database` (where the
-    # metric queries read from) — there is no `database:` field, so the dev
-    # profile below is runnable as-is against a local ClickHouse.
-    profiles_config = """# Database connection profiles
-
-default_profile: dev
-
-profiles:
-  # Local dev — runnable against a local ClickHouse once the databases exist.
+# Active dev/prod profile blocks per backend (indented under `profiles:`).
+_ACTIVE_PROFILES = {
+    "clickhouse": """  # Local dev — runnable against a local ClickHouse once the databases exist.
   # ClickHouse needs BOTH locations (there is no `database:` field):
   #   internal_database -> where detectkit's own _dtk_* tables live
   #   data_database     -> where your metric source tables live
@@ -116,27 +32,106 @@ profiles:
     password: "{{ env_var('CLICKHOUSE_PASSWORD') }}"
     internal_database: detectkit   # _dtk_* tables
     data_database: monitoring      # your source data
+""",
+    "postgres": """  # Local dev — runnable against a local PostgreSQL. PostgreSQL uses SCHEMAS:
+  #   database        -> the database to connect to (must already exist)
+  #   internal_schema -> schema for detectkit's own _dtk_* tables (auto-created)
+  #   data_schema     -> schema your metric source tables live in
+  dev:
+    type: postgres
+    host: localhost
+    port: 5432
+    user: postgres
+    password: postgres
+    database: detectkit
+    internal_schema: detectkit
+    data_schema: public
+
+  # Production — keep secrets in env vars, never commit credentials.
+  prod:
+    type: postgres
+    host: "{{ env_var('POSTGRES_HOST') }}"
+    port: 5432
+    user: "{{ env_var('POSTGRES_USER') }}"
+    password: "{{ env_var('POSTGRES_PASSWORD') }}"
+    database: "{{ env_var('POSTGRES_DB') }}"
+    internal_schema: detectkit
+    data_schema: public
+""",
+    "mysql": """  # Local dev — runnable against a local MySQL (8.0+). MySQL uses DATABASES:
+  #   internal_database -> database for detectkit's own _dtk_* tables (auto-created)
+  #   data_database     -> database your metric source tables live in
+  dev:
+    type: mysql
+    host: localhost
+    port: 3306
+    user: root
+    password: ""
+    internal_database: detectkit
+    data_database: analytics
 
-  # Example PostgreSQL profile (uses internal_schema / data_schema)
+  # Production — keep secrets in env vars, never commit credentials.
+  prod:
+    type: mysql
+    host: "{{ env_var('MYSQL_HOST') }}"
+    port: 3306
+    user: "{{ env_var('MYSQL_USER') }}"
+    password: "{{ env_var('MYSQL_PASSWORD') }}"
+    internal_database: detectkit
+    data_database: monitoring
+""",
+}
+
+# Commented single-profile examples for the backends that are NOT active.
+_COMMENTED_EXAMPLES = {
+    "clickhouse": """  # Example ClickHouse profile (needs internal_database + data_database)
+  # clickhouse_dev:
+  #   type: clickhouse
+  #   host: localhost
+  #   port: 9000
+  #   user: default
+  #   password: ""
+  #   internal_database: detectkit
+  #   data_database: default
+""",
+    "postgres": """  # Example PostgreSQL profile (connect to `database`; tables live in schemas)
   # postgres_dev:
   #   type: postgres
   #   host: localhost
   #   port: 5432
   #   user: postgres
   #   password: postgres
+  #   database: detectkit
   #   internal_schema: detectkit
   #   data_schema: public
-
-  # Example MySQL profile
+""",
+    "mysql": """  # Example MySQL profile (8.0+; internal_database + data_database)
   # mysql_dev:
   #   type: mysql
   #   host: localhost
   #   port: 3306
   #   user: root
-  #   password: root
+  #   password: ""
   #   internal_database: detectkit
   #   data_database: analytics
-
+""",
+}
+
+# Timestamp-bucketing expression for the example metric query, per dialect.
+_BUCKET_SQL = {
+    "clickhouse": "toStartOfInterval(event_time, INTERVAL {{ interval_seconds }} SECOND)",
+    "postgres": (
+        "to_timestamp(floor(extract(epoch from event_time) / {{ interval_seconds }})"
+        " * {{ interval_seconds }})"
+    ),
+    "mysql": (
+        "FROM_UNIXTIME(FLOOR(UNIX_TIMESTAMP(event_time) / {{ interval_seconds }})"
+        " * {{ interval_seconds }})"
+    ),
+}
+
+# Alert-channel section (backend-independent); appended after the profiles.
+_ALERT_CHANNELS = """
 # Alert channels (referenced by name from a metric's alerting.channels)
 alert_channels:
   # Mattermost. Supported keys: webhook_url, username, icon_emoji, channel,
@@ -179,9 +174,103 @@ alert_channels:
   #     Authorization: "Bearer {{ env_var('WEBHOOK_TOKEN') }}"
 """
 
+
+def run_init(project_name: str, target_dir: str, db_type: str = "clickhouse"):
+    """
+    Initialize a new detectkit project.
+
+    Args:
+        project_name: Name of the project (or path - will extract basename)
+        target_dir: Directory to create project in
+
+    Creates:
+        project_name/
+        ├── detectkit_project.yml
+        ├── profiles.yml
+        ├── metrics/
+        │   └── .gitkeep
+        └── sql/
+            └── .gitkeep
+    """
+    # Extract just the directory name in case user passes a full path
+    project_name_clean = Path(project_name).name
+    target_path = Path(target_dir) / project_name_clean
+
+    # Check if project already exists
+    if target_path.exists():
+        click.echo(
+            click.style(
+                f"Error: Directory '{target_path}' already exists!",
+                fg="red",
+                bold=True,
+            )
+        )
+        return
+
+    # Create project directory
+    click.echo(f"Creating detectkit project '{project_name_clean}' in {target_dir}...")
+
+    target_path.mkdir(parents=True, exist_ok=True)
+
+    # Create subdirectories
+    (target_path / "metrics").mkdir(exist_ok=True)
+    (target_path / "sql").mkdir(exist_ok=True)
+
+    # Create .gitkeep files
+    (target_path / "metrics" / ".gitkeep").touch()
+    (target_path / "sql" / ".gitkeep").touch()
+
+    # Create detectkit_project.yml
+    project_config = f"""# detectkit project configuration
+name: {project_name_clean}
+version: '1.0'
+
+# Directory paths. These are the real config keys (nested under `paths:`);
+# a flat `metrics_path:` / `sql_path:` is not a recognized field and is ignored.
+paths:
+  metrics: metrics
+  sql: sql
+  templates: templates
+
+# Default profile to use (must exist in profiles.yml)
+default_profile: dev
+
+# Default table names (can be overridden in metrics)
+tables:
+  datapoints: _dtk_datapoints
+  detections: _dtk_detections
+  tasks: _dtk_tasks
+
+# Default timeouts (seconds)
+timeouts:
+  load: 1800      # 30 minutes
+  detect: 3600    # 1 hour
+  alert: 300      # 5 minutes
+"""
+
+    (target_path / "detectkit_project.yml").write_text(project_config)
+
+    # Create profiles.yml (must validate against ProfilesConfig: connections
+    # live under a top-level 'profiles:' mapping). The active dev/prod profiles
+    # are scaffolded for the chosen --db-type; the other backends are included
+    # as commented examples. See the per-database docs for connection details.
+    other_backends = [t for t in ("clickhouse", "postgres", "mysql") if t != db_type]
+    commented = "\n".join(_COMMENTED_EXAMPLES[t] for t in other_backends)
+    profiles_config = (
+        "# Database connection profiles\n\n"
+        "default_profile: dev\n\n"
+        "profiles:\n"
+        f"{_ACTIVE_PROFILES[db_type]}\n"
+        f"{commented}"
+        f"{_ALERT_CHANNELS}"
+    )
+
     (target_path / "profiles.yml").write_text(profiles_config)
 
-    # Create example metric (must validate against MetricConfig)
+    # Create example metric (must validate against MetricConfig). The
+    # timestamp-bucketing expression is dialect-specific; it is substituted for
+    # the __DTK_BUCKET__ sentinel below so the Jinja `{{ }}` placeholders in the
+    # rest of the query are left untouched.
     example_metric = """# Example metric configuration
 name: example_cpu_usage
 description: CPU usage monitoring example
@@ -191,7 +280,7 @@ description: CPU usage monitoring example
 #   {{ interval_seconds }} - metric interval in seconds
 query: |
   SELECT
-    toStartOfInterval(event_time, INTERVAL {{ interval_seconds }} SECOND) AS timestamp,
+    __DTK_BUCKET__ AS timestamp,
     avg(cpu_usage) AS value
   FROM system_metrics
   WHERE event_time >= '{{ dtk_start_time }}'
@@ -252,6 +341,7 @@ tags:
   - system
 """
 
+    example_metric = example_metric.replace("__DTK_BUCKET__", _BUCKET_SQL[db_type])
     (target_path / "metrics" / "example_cpu_usage.yml").write_text(example_metric)
 
     # Create README
@@ -315,7 +405,7 @@ See https://github.com/alexeiveselov92/detectkit for full documentation.
     click.echo()
     click.echo("Next steps:")
     click.echo(f"  1. cd {project_name}")
-    click.echo("  2. Configure database connection in profiles.yml")
+    click.echo(f"  2. Configure your {db_type} connection in profiles.yml")
     click.echo("  3. Create or edit metric definitions in metrics/")
     click.echo("  4. Run: dtk run --select example_cpu_usage")
     click.echo()

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/cli/main.py

@@ -36,23 +36,31 @@ def cli():
     default=".",
     help="Directory to create project in (default: current directory)",
 )
-def init(project_name: str, target_dir: str):
+@click.option(
+    "--db-type",
+    type=click.Choice(["clickhouse", "postgres", "mysql"]),
+    default="clickhouse",
+    show_default=True,
+    help="Database backend to scaffold the dev/prod profiles and example query for.",
+)
+def init(project_name: str, target_dir: str, db_type: str):
     """
     Initialize a new detectkit project.
 
     Creates project structure with configuration files and directories:
     - detectkit_project.yml (project config)
-    - profiles.yml (database connections)
+    - profiles.yml (database connections — for the chosen --db-type)
     - metrics/ (metric definitions)
     - sql/ (SQL queries)
 
     Example:
         dtk init my_monitoring_project
         dtk init analytics --target-dir /opt/projects
+        dtk init my_project --db-type postgres
     """
     from detectkit.cli.commands.init import run_init
 
-    run_init(project_name, target_dir)
+    run_init(project_name, target_dir, db_type=db_type)
 
 
 @cli.command(name="init-claude")

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/config/profile.py

@@ -41,6 +41,13 @@ class ProfileConfig(BaseModel):
     user: str = Field(default="default", description="Database user")
     password: str = Field(default="", description="Database password")
 
+    # Connection-target database. Required for PostgreSQL (the database to
+    # connect to, inside which internal_schema/data_schema live); optional for
+    # MySQL; unused for ClickHouse.
+    database: str | None = Field(
+        default=None, description="Database to connect to (PostgreSQL/MySQL)"
+    )
+
     # Internal location for _dtk_* tables
     internal_database: str | None = Field(
         default=None, description="Database for internal tables (ClickHouse/MySQL)"
@@ -136,7 +143,9 @@ class ProfileConfig(BaseModel):
             Database manager instance
 
         Raises:
-            NotImplementedError: If database type not yet implemented
+            ValueError: If the database type is unsupported, or required
+                connection fields (e.g. PostgreSQL ``database``) are missing
+            ImportError: If the backend's driver is not installed
         """
         if self.type == "clickhouse":
             return ClickHouseDatabaseManager(
@@ -149,9 +158,36 @@ class ProfileConfig(BaseModel):
                 settings=self.settings,
             )
         elif self.type == "postgres":
-            raise NotImplementedError("PostgreSQL support coming soon")
+            from detectkit.database.postgres_manager import PostgresDatabaseManager
+
+            if not self.database:
+                raise ValueError(
+                    "PostgreSQL profiles must set 'database' (the database to "
+                    "connect to, inside which internal_schema/data_schema live)"
+                )
+            return PostgresDatabaseManager(
+                host=self.host,
+                port=self.port,
+                user=self.user,
+                password=self.password,
+                database=self.database,
+                internal_schema=self.get_internal_location(),
+                data_schema=self.get_data_location(),
+                settings=self.settings,
+            )
         elif self.type == "mysql":
-            raise NotImplementedError("MySQL support coming soon")
+            from detectkit.database.mysql_manager import MySQLDatabaseManager
+
+            return MySQLDatabaseManager(
+                host=self.host,
+                port=self.port,
+                user=self.user,
+                password=self.password,
+                database=self.database,
+                internal_database=self.get_internal_location(),
+                data_database=self.get_data_location(),
+                settings=self.settings,
+            )
         else:
             raise ValueError(f"Unsupported database type: {self.type}")
 

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/core/models.py

@@ -47,6 +47,12 @@ class TableModel:
         engine: Database engine (ClickHouse-specific, e.g., "MergeTree")
         order_by: Columns for ORDER BY clause (ClickHouse-specific)
         indexes: Additional indexes to create
+        version_column: Column that drives last-writer-wins deduplication.
+            On ClickHouse this is the version encoded in the engine string
+            (e.g. ``ReplacingMergeTree(created_at)``); on SQL backends with an
+            enforced primary key it drives a version-aware upsert so a re-insert
+            with a newer ``version_column`` replaces the existing row. ``None``
+            for tables that do not deduplicate by version (e.g. ``_dtk_tasks``).
 
     Example:
         >>> model = TableModel(
@@ -65,6 +71,7 @@ class TableModel:
     engine: str | None = None
     order_by: list[str] | None = None
     indexes: list[str] = field(default_factory=list)
+    version_column: str | None = None
 
     def __post_init__(self):
         """Validate table model."""
@@ -86,6 +93,10 @@ class TableModel:
                 if order_col not in column_names:
                     raise ValueError(f"ORDER BY column '{order_col}' not found in table columns")
 
+        # Validate version column exists (if specified)
+        if self.version_column and self.version_column not in column_names:
+            raise ValueError(f"Version column '{self.version_column}' not found in table columns")
+
     def get_column(self, name: str) -> ColumnDefinition | None:
         """
         Get column definition by name.

{detectkit-0.10.0 → detectkit-0.11.0}/detectkit/database/__init__.py

@@ -1,8 +1,11 @@
 """Database managers for detectk."""
 
+from detectkit.database._sql_manager import SQLDatabaseManager
 from detectkit.database.clickhouse_manager import ClickHouseDatabaseManager
 from detectkit.database.internal_tables import InternalTablesManager
 from detectkit.database.manager import BaseDatabaseManager
+from detectkit.database.mysql_manager import MySQLDatabaseManager
+from detectkit.database.postgres_manager import PostgresDatabaseManager
 from detectkit.database.tables import (
     INTERNAL_TABLES,
     TABLE_DATAPOINTS,
@@ -16,6 +19,9 @@ from detectkit.database.tables import (
 __all__ = [
     "BaseDatabaseManager",
     "ClickHouseDatabaseManager",
+    "SQLDatabaseManager",
+    "PostgresDatabaseManager",
+    "MySQLDatabaseManager",
     "InternalTablesManager",
     "TABLE_DATAPOINTS",
     "TABLE_DETECTIONS",