databao-context-engine 0.1.1__py3-none-any.whl → 0.1.5__py3-none-any.whl

databao_context_engine/plugins/databases/sqlite/sqlite_introspector.py

@@ -0,0 +1,241 @@
+import sqlite3
+
+from pydantic import BaseModel, Field
+
+from databao_context_engine.plugins.databases.base_db_plugin import BaseDatabaseConfigFile
+from databao_context_engine.plugins.databases.base_introspector import BaseIntrospector, SQLQuery
+from databao_context_engine.plugins.databases.databases_types import DatabaseSchema
+from databao_context_engine.plugins.databases.introspection_model_builder import IntrospectionModelBuilder
+
+
+class SQLiteConnectionConfig(BaseModel):
+    database_path: str = Field(description="Path to the SQLite database file")
+
+
+class SQLiteConfigFile(BaseDatabaseConfigFile):
+    type: str = Field(default="sqlite")
+    connection: SQLiteConnectionConfig
+
+
+class SQLiteIntrospector(BaseIntrospector[SQLiteConfigFile]):
+    _IGNORED_SCHEMAS = {"temp", "information_schema"}
+    _PSEUDO_SCHEMA = "main"
+    supports_catalogs = False
+
+    def _connect(self, file_config: SQLiteConfigFile, *, catalog: str | None = None):
+        database_path = str(file_config.connection.database_path)
+        conn = sqlite3.connect(database_path)
+        conn.text_factory = str
+        return conn
+
+    def _get_catalogs(self, connection, file_config: SQLiteConfigFile) -> list[str]:
+        return [self._resolve_pseudo_catalog_name(file_config)]
+
+    def _fetchall_dicts(self, connection, sql: str, params) -> list[dict]:
+        cur = connection.cursor()
+        if params is None:
+            cur.execute(sql)
+        else:
+            cur.execute(sql, params)
+
+        if cur.description is None:
+            return []
+
+        rows = cur.fetchall()
+        out: list[dict] = []
+        for r in rows:
+            if isinstance(r, sqlite3.Row):
+                out.append({k.lower(): r[k] for k in r.keys()})
+            else:
+                cols = [d[0].lower() for d in cur.description]
+                out.append(dict(zip(cols, r)))
+        return out
+
+    def _list_schemas_for_catalog(self, connection, catalog: str) -> list[str]:
+        return [self._PSEUDO_SCHEMA]
+
+    def collect_catalog_model(self, connection, catalog: str, schemas: list[str]) -> list[DatabaseSchema] | None:
+        if not schemas:
+            return []
+
+        comps = self._component_queries()
+        results: dict[str, list[dict]] = {name: [] for name in comps}
+
+        for name, sql in comps.items():
+            results[name] = self._fetchall_dicts(connection, sql, None) or []
+
+        return IntrospectionModelBuilder.build_schemas_from_components(
+            schemas=[self._PSEUDO_SCHEMA],
+            rels=results.get("relations", []),
+            cols=results.get("columns", []),
+            pk_cols=results.get("pk", []),
+            uq_cols=results.get("uq", []),
+            checks=[],
+            fk_cols=results.get("fks", []),
+            idx_cols=results.get("idx", []),
+            partitions=[],
+        )
+
+    def _component_queries(self) -> dict[str, str]:
+        return {
+            "relations": self._sql_relations(),
+            "columns": self._sql_columns(),
+            "pk": self._sql_primary_keys(),
+            "uq": self._sql_unique(),
+            "fks": self._sql_foreign_keys(),
+            "idx": self._sql_indexes(),
+        }
+
+    def _sql_relations(self) -> str:
+        return f"""
+            SELECT
+                '{self._PSEUDO_SCHEMA}' AS schema_name,
+                m.name AS table_name,
+                CASE m.type
+                    WHEN 'view' THEN 'view'
+                    ELSE 'table'
+                END AS kind,
+                NULL AS description
+            FROM 
+                sqlite_master m
+            WHERE
+                m.type IN ('table', 'view')
+                AND m.name NOT LIKE 'sqlite_%'
+            ORDER BY
+                m.name;
+        """
+
+    def _sql_columns(self) -> str:
+        return f"""
+            SELECT
+                '{self._PSEUDO_SCHEMA}' AS schema_name,
+                m.name AS table_name,
+                c.name AS column_name,
+                (c.cid + 1) AS ordinal_position,
+                COALESCE(c.type,'') AS data_type,
+                CASE 
+                    WHEN c.pk > 0 THEN 0 
+                    WHEN c."notnull" = 0 THEN 1 
+                    ELSE 0 
+                END AS is_nullable,
+                c.dflt_value AS default_expression,
+                CASE
+                    WHEN c.hidden IN (2,3) THEN 'computed'
+                END AS generated,
+                NULL AS description
+            FROM 
+                sqlite_master m
+                JOIN pragma_table_xinfo(m.name) c
+            WHERE 
+                m.type IN ('table','view')
+                AND m.name NOT LIKE 'sqlite_%'
+            ORDER BY 
+                m.name, 
+                c.cid;
+        """
+
+    def _sql_primary_keys(self) -> str:
+        return f"""
+            SELECT
+                '{self._PSEUDO_SCHEMA}' AS schema_name,
+                m.name AS table_name,
+                ('pk_' || m.name) AS constraint_name,
+                c.pk AS position,
+                c.name AS column_name
+            FROM 
+                sqlite_master m
+                JOIN pragma_table_info(m.name) c
+            WHERE
+                m.type = 'table'
+                AND m.name NOT LIKE 'sqlite_%'
+                AND c.pk > 0
+            ORDER BY
+                m.name,
+                c.pk;
+        """
+
+    def _sql_unique(self) -> str:
+        return f"""
+            SELECT
+                '{self._PSEUDO_SCHEMA}' AS schema_name,
+                m.name AS table_name,
+                il.name AS constraint_name,
+                (ii.seqno + 1) AS position,
+                ii.name AS column_name
+            FROM 
+                sqlite_master m
+                JOIN pragma_index_list(m.name) il
+                JOIN pragma_index_info(il.name) ii
+            WHERE
+                m.type = 'table'
+                AND m.name NOT LIKE 'sqlite_%'
+                AND il."unique" = 1
+                AND il.origin = 'u'
+            ORDER BY
+                m.name,
+                il.name,
+                ii.seqno;
+        """
+
+    def _sql_foreign_keys(self) -> str:
+        return f"""
+            SELECT
+                '{self._PSEUDO_SCHEMA}' AS schema_name,
+                m.name AS table_name,
+                ('fk_' || m.name || '_' || fk.id) AS constraint_name,
+                (fk.seq + 1) AS position,
+                fk."from" AS from_column,
+                'main' AS ref_schema,
+                fk."table" AS ref_table,
+                fk."to" AS to_column,
+                lower(fk.on_update) AS on_update,
+                lower(fk.on_delete) AS on_delete,
+                1 AS enforced,
+                1 AS validated
+            FROM sqlite_master m
+            JOIN pragma_foreign_key_list(m.name) fk
+            WHERE
+                m.type = 'table'
+                AND m.name NOT LIKE 'sqlite_%'
+            ORDER BY
+                m.name,
+                fk.id,
+                fk.seq;
+        """
+
+    def _sql_indexes(self) -> str:
+        return f"""
+            SELECT
+                '{self._PSEUDO_SCHEMA}' AS schema_name,
+                m.name AS table_name,
+                il.name AS index_name,
+                (ix.seqno + 1) AS position,
+                ix.name AS expr,
+                il."unique" AS is_unique,
+                NULL AS method,
+                CASE
+                    WHEN il.partial = 1 AND sm.sql IS NOT NULL AND instr(upper(sm.sql), 'WHERE') > 0
+                    THEN trim(substr(sm.sql, instr(upper(sm.sql), 'WHERE') + length('WHERE')))
+                END AS predicate
+            FROM 
+                sqlite_master m
+                JOIN pragma_index_list(m.name) il
+                JOIN pragma_index_xinfo(il.name) ix
+                LEFT JOIN sqlite_master sm ON sm.type = 'index' AND sm.name = il.name
+            WHERE 
+                m.type='table'
+                AND m.name NOT LIKE 'sqlite_%'
+                AND lower(il.origin) = 'c'
+                AND ix.key = 1
+            ORDER BY 
+                m.name, 
+                il.name, 
+                ix.seqno;
+        """
+
+    def _sql_sample_rows(self, catalog: str, schema: str, table: str, limit: int) -> SQLQuery:
+        sql = f"SELECT * FROM {self._quote_ident(table)} LIMIT ?"
+        return SQLQuery(sql, (limit,))
+
+    def _quote_ident(self, ident: str) -> str:
+        return '"' + str(ident).replace('"', '""') + '"'

databao_context_engine/plugins/duckdb_tools.py

@@ -0,0 +1,18 @@
+from typing import Any
+
+from databao_context_engine.pluginlib.config import DuckDBSecret
+
+
+def generate_create_secret_sql(secret_name, duckdb_secret: DuckDBSecret) -> str:
+    parameters = [("type", duckdb_secret.type)] + list(duckdb_secret.properties.items())
+    return f"""CREATE SECRET {secret_name} (
+    {", ".join([f"{k} '{v}'" for (k, v) in parameters])}
+);
+"""
+
+
+def fetchall_dicts(cur, sql: str, params=None) -> list[dict[str, Any]]:
+    cur.execute(sql, params or [])
+    columns = [desc[0].lower() for desc in cur.description] if cur.description else []
+    rows = cur.fetchall()
+    return [dict(zip(columns, row)) for row in rows]

databao_context_engine/plugins/{unstructured_files_plugin.py → files/unstructured_files_plugin.py}

@@ -24,7 +24,7 @@ class InternalUnstructuredFilesPlugin(BuildFilePlugin):
         self.tokens_overlap = tokens_overlap or self._DEFAULT_TOKENS_OVERLAP
 
     def supported_types(self) -> set[str]:
-        return {f"files/{extension}" for extension in self._SUPPORTED_FILES_EXTENSIONS}
+        return self._SUPPORTED_FILES_EXTENSIONS
 
     def build_file_context(self, full_type: str, file_name: str, file_buffer: BufferedReader) -> Any:
         file_content = self._read_file(file_buffer)

databao_context_engine/plugins/plugin_loader.py

@@ -14,31 +14,12 @@ class DuplicatePluginTypeError(RuntimeError):
     """Raised when two plugins register the same <main>/<sub> plugin key."""
 
 
-PluginList = dict[DatasourceType, BuildPlugin]
-
-
-def get_all_available_plugin_types(exclude_file_plugins: bool = False) -> set[DatasourceType]:
-    return set(load_plugins(exclude_file_plugins=exclude_file_plugins).keys())
-
-
-def get_plugin_for_type(datasource_type: DatasourceType) -> BuildPlugin:
-    all_plugins = load_plugins()
-
-    if datasource_type not in all_plugins:
-        raise ValueError(f"No plugin found for type '{datasource_type.full_type}'")
-
-    return load_plugins()[datasource_type]
-
-
-def load_plugins(exclude_file_plugins: bool = False) -> PluginList:
-    """
-    Loads both builtin and external plugins and merges them into one list
-    """
+def load_plugins(exclude_file_plugins: bool = False) -> dict[DatasourceType, BuildPlugin]:
+    """Load both builtin and external plugins and merges them into one list."""
     builtin_plugins = _load_builtin_plugins(exclude_file_plugins)
     external_plugins = _load_external_plugins(exclude_file_plugins)
-    plugins = merge_plugins(builtin_plugins, external_plugins)
 
-    return plugins
+    return _merge_plugins(builtin_plugins, external_plugins)
 
 
 def _load_builtin_plugins(exclude_file_plugins: bool = False) -> list[BuildPlugin]:
@@ -53,7 +34,7 @@ def _load_builtin_plugins(exclude_file_plugins: bool = False) -> list[BuildPlugi
 
 
 def _load_builtin_file_plugins() -> list[BuildFilePlugin]:
-    from databao_context_engine.plugins.unstructured_files_plugin import InternalUnstructuredFilesPlugin
+    from databao_context_engine.plugins.files.unstructured_files_plugin import InternalUnstructuredFilesPlugin
 
     return [
         InternalUnstructuredFilesPlugin(),
@@ -61,43 +42,68 @@ def _load_builtin_file_plugins() -> list[BuildFilePlugin]:
 
 
 def _load_builtin_datasource_plugins() -> list[BuildDatasourcePlugin]:
-    """
-    Statically register built-in plugins
-    """
-    from databao_context_engine.plugins.athena_db_plugin import AthenaDbPlugin
-    from databao_context_engine.plugins.clickhouse_db_plugin import ClickhouseDbPlugin
-    from databao_context_engine.plugins.duckdb_db_plugin import DuckDbPlugin
-    from databao_context_engine.plugins.mssql_db_plugin import MSSQLDbPlugin
-    from databao_context_engine.plugins.mysql_db_plugin import MySQLDbPlugin
-    from databao_context_engine.plugins.parquet_plugin import ParquetPlugin
-    from databao_context_engine.plugins.postgresql_db_plugin import PostgresqlDbPlugin
-    from databao_context_engine.plugins.snowflake_db_plugin import SnowflakeDbPlugin
+    """Statically register built-in plugins."""
+    from databao_context_engine.plugins.databases.duckdb.duckdb_db_plugin import DuckDbPlugin
+    from databao_context_engine.plugins.databases.sqlite.sqlite_db_plugin import SQLiteDbPlugin
+    from databao_context_engine.plugins.resources.parquet_plugin import ParquetPlugin
 
-    return [
-        AthenaDbPlugin(),
-        ClickhouseDbPlugin(),
-        DuckDbPlugin(),
-        MSSQLDbPlugin(),
-        MySQLDbPlugin(),
-        PostgresqlDbPlugin(),
-        SnowflakeDbPlugin(),
-        ParquetPlugin(),
-    ]
+    # optional plugins are added to the python environment via extras
+    optional_plugins: list[BuildDatasourcePlugin] = []
+    try:
+        from databao_context_engine.plugins.databases.mssql.mssql_db_plugin import MSSQLDbPlugin
+
+        optional_plugins = [MSSQLDbPlugin()]
+    except ImportError:
+        pass
+
+    try:
+        from databao_context_engine.plugins.databases.clickhouse.clickhouse_db_plugin import ClickhouseDbPlugin
+
+        optional_plugins.append(ClickhouseDbPlugin())
+    except ImportError:
+        pass
+
+    try:
+        from databao_context_engine.plugins.databases.athena.athena_db_plugin import AthenaDbPlugin
+
+        optional_plugins.append(AthenaDbPlugin())
+    except ImportError:
+        pass
+
+    try:
+        from databao_context_engine.plugins.databases.snowflake.snowflake_db_plugin import SnowflakeDbPlugin
+
+        optional_plugins.append(SnowflakeDbPlugin())
+    except ImportError:
+        pass
+
+    try:
+        from databao_context_engine.plugins.databases.mysql.mysql_db_plugin import MySQLDbPlugin
+
+        optional_plugins.append(MySQLDbPlugin())
+    except ImportError:
+        pass
+
+    try:
+        from databao_context_engine.plugins.databases.postgresql.postgresql_db_plugin import PostgresqlDbPlugin
+
+        optional_plugins.append(PostgresqlDbPlugin())
+    except ImportError:
+        pass
+
+    required_plugins: list[BuildDatasourcePlugin] = [DuckDbPlugin(), ParquetPlugin(), SQLiteDbPlugin()]
+    return required_plugins + optional_plugins
 
 
 def _load_external_plugins(exclude_file_plugins: bool = False) -> list[BuildPlugin]:
-    """
-    Discover external plugins via entry points
-    """
+    """Discover external plugins via entry points."""
     # TODO: implement external plugin loading
     return []
 
 
-def merge_plugins(*plugin_lists: list[BuildPlugin]) -> PluginList:
-    """
-    Merge multiple plugin maps
-    """
-    registry: PluginList = {}
+def _merge_plugins(*plugin_lists: list[BuildPlugin]) -> dict[DatasourceType, BuildPlugin]:
+    """Merge multiple plugin maps."""
+    registry: dict[DatasourceType, BuildPlugin] = {}
     for plugins in plugin_lists:
         for plugin in plugins:
             for full_type in plugin.supported_types():

databao_context_engine/plugins/resources/parquet_introspector.py

@@ -6,21 +6,21 @@ from dataclasses import dataclass, replace
 from urllib.parse import urlparse
 
 import duckdb
-from _duckdb import DuckDBPyConnection
+from duckdb import DuckDBPyConnection
 from pydantic import BaseModel, Field
 
 from databao_context_engine.pluginlib.config import DuckDBSecret
+from databao_context_engine.plugins.duckdb_tools import fetchall_dicts, generate_create_secret_sql
 
-parquet_type = "resources/parquet"
+parquet_type = "parquet"
 
 logger = logging.getLogger(__name__)
 
 
 class ParquetConfigFile(BaseModel):
     name: str | None = Field(default=None)
-    type: str = Field(default=parquet_type)
+    type: str = Field(default="parquet")
     url: str = Field(
-        default=type,
         description="Parquet resource location. Should be a valid URL or a path to a local file. "
         "Examples: s3://your_bucket/file.parquet, s3://your-bucket/*.parquet, https://some.url/some_file.parquet, ~/path_to/file.parquet",
     )
@@ -50,14 +50,6 @@ class ParquetIntrospectionResult:
     files: list[ParquetFile]
 
 
-def generate_create_secret_sql(secret_name, duckdb_secret: DuckDBSecret) -> str:
-    parameters = [("type", duckdb_secret.type)] + list(duckdb_secret.properties.items())
-    return f"""CREATE SECRET {secret_name} (
-    {", ".join([f"{k} {v}" for (k, v) in parameters])}
-);
-"""
-
-
 @contextlib.contextmanager
 def _create_secret(conn: DuckDBPyConnection, duckdb_secret: DuckDBSecret):
     secret_name = duckdb_secret.name or "gen_secret_" + str(uuid.uuid4()).replace("-", "_")
@@ -98,10 +90,9 @@ class ParquetIntrospector:
         with self._connect(file_config) as conn:
             with conn.cursor() as cur:
                 resolved_url = _resolve_url(file_config)
-                cur.execute(f"SELECT * FROM parquet_file_metadata('{resolved_url}') LIMIT 1")
-                columns = [desc[0].lower() for desc in cur.description] if cur.description else []
-                rows = cur.fetchall()
-                parquet_file_metadata = [dict(zip(columns, row)) for row in rows]
+                parquet_file_metadata = fetchall_dicts(
+                    cur, f"SELECT * FROM parquet_file_metadata('{resolved_url}') LIMIT 1"
+                )
                 if not parquet_file_metadata:
                     raise ValueError(f"No parquet files found by url {resolved_url}")
                 if not parquet_file_metadata or not parquet_file_metadata[0]["file_name"]:
@@ -111,10 +102,7 @@ class ParquetIntrospector:
         with self._connect(file_config) as conn:
             with conn.cursor() as cur:
                 resolved_url = _resolve_url(file_config)
-                cur.execute(f"SELECT * from parquet_metadata('{resolved_url}')")
-                cols = [desc[0].lower() for desc in cur.description] if cur.description else []
-                rows = cur.fetchall()
-                file_metas = [dict(zip(cols, row)) for row in rows]
+                file_metas = fetchall_dicts(cur, f"SELECT * from parquet_metadata('{resolved_url}')")
 
                 columns_per_file: dict[str, dict[int, ParquetColumn]] = defaultdict(defaultdict)
                 for file_meta in file_metas:

databao_context_engine/plugins/{parquet_plugin.py → resources/parquet_plugin.py}

@@ -24,9 +24,7 @@ class ParquetPlugin(BuildDatasourcePlugin[ParquetConfigFile]):
         return build_parquet_chunks(context)
 
     def build_context(self, full_type: str, datasource_name: str, file_config: ParquetConfigFile) -> Any:
-        introspection_result = self._introspector.introspect(file_config)
-
-        return introspection_result
+        return self._introspector.introspect(file_config)
 
     def check_connection(self, full_type: str, datasource_name: str, file_config: ParquetConfigFile) -> None:
         self._introspector.check_connection(file_config)

databao_context_engine/project/info.py

@@ -3,29 +3,56 @@ from importlib.metadata import version
 from pathlib import Path
 from uuid import UUID
 
+from databao_context_engine.plugins.plugin_loader import load_plugins
 from databao_context_engine.project.layout import validate_project_dir
 from databao_context_engine.system.properties import get_dce_path
 
 
 @dataclass(kw_only=True, frozen=True)
 class DceProjectInfo:
+    """Information about a Databao Context Engine project.
+
+    Attributes:
+        project_path: The root directory of the Databao Context Engine project.
+        is_initialized: Whether the project has been initialized.
+        project_id: The UUID of the project, or None if the project has not been initialized.
+    """
+
     project_path: Path
-    is_initialised: bool
+    is_initialized: bool
     project_id: UUID | None
 
 
 @dataclass(kw_only=True, frozen=True)
 class DceInfo:
+    """Information about the current Databao Context Engine installation and project.
+
+    Attributes:
+        version: The version of the databao_context_engine package installed on the system.
+        dce_path: The path where databao_context_engine stores its global data.
+        project_info: Information about the Databao Context Engine project.
+    """
+
     version: str
     dce_path: Path
+    plugin_ids: list[str]
 
     project_info: DceProjectInfo
 
 
 def get_databao_context_engine_info(project_dir: Path) -> DceInfo:
+    """Return information about the current Databao Context Engine installation and project.
+
+    Args:
+        project_dir: The root directory of the Databao Context Project.
+
+    Returns:
+        A DceInfo instance containing information about the Databao Context Engine installation and project.
+    """
     return DceInfo(
         version=get_dce_version(),
         dce_path=get_dce_path(),
+        plugin_ids=[plugin.id for plugin in load_plugins().values()],
         project_info=_get_project_info(project_dir),
     )
 
@@ -35,10 +62,15 @@ def _get_project_info(project_dir: Path) -> DceProjectInfo:
 
     return DceProjectInfo(
         project_path=project_dir,
-        is_initialised=project_layout is not None,
+        is_initialized=project_layout is not None,
         project_id=project_layout.read_config_file().project_id if project_layout is not None else None,
     )
 
 
 def get_dce_version() -> str:
+    """Return the installed version of the databao_context_engine package.
+
+    Returns:
+        The installed version of the databao_context_engine package.
+    """
     return version("databao_context_engine")

databao_context_engine/project/init_project.py

@@ -13,12 +13,21 @@ from databao_context_engine.project.project_config import ProjectConfig
 
 
 class InitErrorReason(Enum):
+    """Reasons for which project initialization can fail."""
+
     PROJECT_DIR_DOESNT_EXIST = "PROJECT_DIR_DOESNT_EXIST"
     PROJECT_DIR_NOT_DIRECTORY = "PROJECT_DIR_NOT_DIRECTORY"
-    PROJECT_DIR_ALREADY_INITIALISED = "PROJECT_DIR_ALREADY_INITIALISED"
+    PROJECT_DIR_ALREADY_INITIALIZED = "PROJECT_DIR_ALREADY_INITIALIZED"
 
 
 class InitProjectError(Exception):
+    """Raised when a project can't be initialized.
+
+    Attributes:
+        message: The error message.
+        reason: The reason for the initialization failure.
+    """
+
     reason: InitErrorReason
 
     def __init__(self, reason: InitErrorReason, message: str | None):
@@ -65,20 +74,20 @@ class _ProjectCreator:
 
         if self.config_file.is_file() or self.deprecated_config_file.is_file():
             raise InitProjectError(
-                message=f"Can't initialise a Databao Context Engine project in a folder that already contains a config file. [project_dir: {self.project_dir.resolve()}]",
-                reason=InitErrorReason.PROJECT_DIR_ALREADY_INITIALISED,
+                message=f"Can't initialize a Databao Context Engine project in a folder that already contains a config file. [project_dir: {self.project_dir.resolve()}]",
+                reason=InitErrorReason.PROJECT_DIR_ALREADY_INITIALIZED,
             )
 
         if self.src_dir.is_dir():
             raise InitProjectError(
-                message=f"Can't initialise a Databao Context Engine project in a folder that already contains a src directory. [project_dir: {self.project_dir.resolve()}]",
-                reason=InitErrorReason.PROJECT_DIR_ALREADY_INITIALISED,
+                message=f"Can't initialize a Databao Context Engine project in a folder that already contains a src directory. [project_dir: {self.project_dir.resolve()}]",
+                reason=InitErrorReason.PROJECT_DIR_ALREADY_INITIALIZED,
             )
 
         if self.examples_dir.is_file():
             raise InitProjectError(
-                message=f"Can't initialise a Databao Context Engine project in a folder that already contains an examples dir. [project_dir: {self.project_dir.resolve()}]",
-                reason=InitErrorReason.PROJECT_DIR_ALREADY_INITIALISED,
+                message=f"Can't initialize a Databao Context Engine project in a folder that already contains an examples dir. [project_dir: {self.project_dir.resolve()}]",
+                reason=InitErrorReason.PROJECT_DIR_ALREADY_INITIALIZED,
             )
 
         return True