PyPI - nao-core - Versions diffs - 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl - Mend

nao-core 0.0.30py3-none-any.whl → 0.0.31py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

nao_core/__init__.py +1 -1
nao_core/bin/fastapi/main.py +6 -0
nao_core/bin/migrations-postgres/0005_add_project_tables.sql +39 -0
nao_core/bin/migrations-postgres/meta/0005_snapshot.json +1129 -0
nao_core/bin/migrations-postgres/meta/_journal.json +7 -0
nao_core/bin/migrations-sqlite/0005_add_project_tables.sql +38 -0
nao_core/bin/migrations-sqlite/meta/0005_snapshot.json +1086 -0
nao_core/bin/migrations-sqlite/meta/_journal.json +7 -0
nao_core/bin/nao-chat-server +0 -0
nao_core/bin/public/assets/{code-block-F6WJLWQG-z4zcca7w.js → code-block-F6WJLWQG-TAi8koem.js} +1 -1
nao_core/bin/public/assets/index-BfHcd9Xz.css +1 -0
nao_core/bin/public/assets/{index-DhhS7iVA.js → index-Mzo9bkag.js} +256 -172
nao_core/bin/public/index.html +2 -2
nao_core/commands/chat.py +11 -10
nao_core/commands/init.py +27 -4
nao_core/commands/sync/__init__.py +40 -21
nao_core/commands/sync/accessors.py +218 -139
nao_core/commands/sync/cleanup.py +133 -0
nao_core/commands/sync/providers/__init__.py +30 -0
nao_core/commands/sync/providers/base.py +87 -0
nao_core/commands/sync/providers/databases/__init__.py +17 -0
nao_core/commands/sync/providers/databases/bigquery.py +78 -0
nao_core/commands/sync/providers/databases/databricks.py +79 -0
nao_core/commands/sync/providers/databases/duckdb.py +83 -0
nao_core/commands/sync/providers/databases/postgres.py +78 -0
nao_core/commands/sync/providers/databases/provider.py +123 -0
nao_core/commands/sync/providers/databases/snowflake.py +78 -0
nao_core/commands/sync/providers/repositories/__init__.py +5 -0
nao_core/commands/sync/{repositories.py → providers/repositories/provider.py} +43 -20
nao_core/config/__init__.py +2 -0
nao_core/config/base.py +23 -4
nao_core/config/databases/__init__.py +5 -0
nao_core/config/databases/base.py +1 -0
nao_core/config/databases/postgres.py +78 -0
nao_core/templates/__init__.py +12 -0
nao_core/templates/defaults/databases/columns.md.j2 +23 -0
nao_core/templates/defaults/databases/description.md.j2 +32 -0
nao_core/templates/defaults/databases/preview.md.j2 +22 -0
nao_core/templates/defaults/databases/profiling.md.j2 +34 -0
nao_core/templates/engine.py +133 -0
{nao_core-0.0.30.dist-info → nao_core-0.0.31.dist-info}/METADATA +6 -2
nao_core-0.0.31.dist-info/RECORD +86 -0
nao_core/bin/public/assets/index-ClduEZSo.css +0 -1
nao_core/commands/sync/databases.py +0 -374
nao_core-0.0.30.dist-info/RECORD +0 -65
{nao_core-0.0.30.dist-info → nao_core-0.0.31.dist-info}/WHEEL +0 -0
{nao_core-0.0.30.dist-info → nao_core-0.0.31.dist-info}/entry_points.txt +0 -0
{nao_core-0.0.30.dist-info → nao_core-0.0.31.dist-info}/licenses/LICENSE +0 -0

nao_core/bin/public/index.html CHANGED Viewed

@@ -9,8 +9,8 @@
 		<link rel="apple-touch-icon" href="/logo192.png" />
 		<link rel="manifest" href="/manifest.json" />
 		<title>nao — Chat with your data</title>
-		<script type="module" crossorigin src="/assets/index-DhhS7iVA.js"></script>
-		<link rel="stylesheet" crossorigin href="/assets/index-ClduEZSo.css">
+		<script type="module" crossorigin src="/assets/index-Mzo9bkag.js"></script>
+		<link rel="stylesheet" crossorigin href="/assets/index-BfHcd9Xz.css">
 	</head>
 	<body>
 		<div id="app"></div>

nao_core/commands/chat.py CHANGED Viewed

@@ -106,18 +106,21 @@ def chat():
     """
     console.print("\n[bold cyan]💬 Starting nao chat...[/bold cyan]\n")
-    binary_path = get_server_binary_path()
-    bin_dir = binary_path.parent
-    console.print(f"[dim]Server binary: {binary_path}[/dim]")
-    console.print(f"[dim]Working directory: {bin_dir}[/dim]")
     # Try to load nao config from current directory
     config = NaoConfig.try_load()
     if config:
         console.print(f"[bold green]✓[/bold green] Loaded config from {Path.cwd() / 'nao_config.yaml'}")
     else:
-        console.print("[dim]No nao_config.yaml found in current directory[/dim]")
+        console.print(
+            "[bold red]✗No nao_config.yaml found in current directory. Please move to a nao project directory.[/bold red]"
+        )
+        sys.exit(1)
+    binary_path = get_server_binary_path()
+    bin_dir = binary_path.parent
+    console.print(f"[dim]Server binary: {binary_path}[/dim]")
+    console.print(f"[dim]Working directory: {bin_dir}[/dim]")
     # Start the server processes
     chat_process = None
@@ -154,10 +157,9 @@ def chat():
         if config and config.slack:
             env["SLACK_BOT_TOKEN"] = config.slack.bot_token
             env["SLACK_SIGNING_SECRET"] = config.slack.signing_secret
-            env["SLACK_POST_MESSAGE_URL"] = config.slack.post_message_url
             console.print("[bold green]✓[/bold green] Set Slack environment variables from config")
-        env["NAO_PROJECT_FOLDER"] = str(Path.cwd())
+        env["NAO_DEFAULT_PROJECT_PATH"] = str(Path.cwd())
         env["FASTAPI_URL"] = f"http://localhost:{FASTAPI_PORT}"
         # Start the FastAPI server first
@@ -166,7 +168,6 @@ def chat():
         fastapi_process = subprocess.Popen(
             [sys.executable, str(fastapi_path)],
-            cwd=str(fastapi_path.parent),
             env=env,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,

nao_core/commands/init.py CHANGED Viewed

@@ -1,4 +1,5 @@
 import os
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Annotated
@@ -16,6 +17,7 @@ from nao_core.config import (
     LLMConfig,
     LLMProvider,
     NaoConfig,
+    PostgresConfig,
     SlackConfig,
     SnowflakeConfig,
 )
@@ -47,6 +49,12 @@ class EmptyApiKeyError(InitError):
         super().__init__("API key cannot be empty.")
+@dataclass
+class CreatedFile:
+    path: Path
+    content: str | None
 def setup_project_name(force: bool = False) -> tuple[str, Path]:
     """Setup the project name."""
     # Check if we're in a directory with an existing nao_config.yaml
@@ -101,6 +109,11 @@ def setup_snowflake() -> SnowflakeConfig:
     return SnowflakeConfig.promptConfig()
+def setup_postgres() -> PostgresConfig:
+    """Setup a PostgreSQL database configuration."""
+    return PostgresConfig.promptConfig()
 def setup_databases() -> list[AnyDatabaseConfig]:
     """Setup database configurations."""
     databases: list[AnyDatabaseConfig] = []
@@ -124,6 +137,10 @@ def setup_databases() -> list[AnyDatabaseConfig]:
             db_config = setup_bigquery()
             databases.append(db_config)
             console.print(f"\n[bold green]✓[/bold green] Added database [cyan]{db_config.name}[/cyan]")
+        elif db_type == DatabaseType.POSTGRES.value:
+            db_config = setup_postgres()
+            databases.append(db_config)
+            console.print(f"\n[bold green]✓[/bold green] Added database [cyan]{db_config.name}[/cyan]")
         elif db_type == DatabaseType.DUCKDB.value:
             db_config = setup_duckdb()
@@ -233,7 +250,7 @@ def setup_slack() -> SlackConfig | None:
     return slack_config
-def create_empty_structure(project_path: Path) -> tuple[list[str], list[str]]:
+def create_empty_structure(project_path: Path) -> tuple[list[str], list[CreatedFile]]:
     """Create project folder structure to guide users.
     To add new folders, simply append them to the FOLDERS list below.
@@ -249,7 +266,10 @@ def create_empty_structure(project_path: Path) -> tuple[list[str], list[str]]:
         "agent/mcps",
     ]
-    FILES = ["RULES.md"]
+    FILES = [
+        CreatedFile(path=Path("RULES.md"), content=None),
+        CreatedFile(path=Path(".naoignore"), content="templates/\n"),
+    ]
     created_folders = []
     for folder in FOLDERS:
@@ -259,8 +279,11 @@ def create_empty_structure(project_path: Path) -> tuple[list[str], list[str]]:
     created_files = []
     for file in FILES:
-        file_path = project_path / file
-        file_path.touch()
+        file_path = project_path / file.path
+        if file.content:
+            file_path.write_text(file.content)
+        else:
+            file_path.touch()
         created_files.append(file)
     return created_folders, created_files

nao_core/commands/sync/__init__.py CHANGED Viewed

@@ -7,50 +7,69 @@ from rich.console import Console
 from nao_core.config import NaoConfig
-from .databases import sync_databases
-from .repositories import sync_repositories
+from .providers import SyncProvider, SyncResult, get_all_providers
 console = Console()
-def sync(output_dir: str = "databases", repos_dir: str = "repos"):
-    """Sync repositories and database schemas to local files.
+def sync(
+    output_dirs: dict[str, str] | None = None,
+    providers: list[SyncProvider] | None = None,
+):
+    """Sync resources using configured providers.
-    Creates folder structures:
+    Creates folder structures based on each provider's default output directory:
       - repos/<repo_name>/         (git repositories)
-      - databases/bigquery/<connection>/<dataset>/<table>/*.md  (database schemas)
+      - databases/<type>/<connection>/<dataset>/<table>/*.md  (database schemas)
     Args:
-            output_dir: Output directory for database schemas (default: "databases")
-            repos_dir: Output directory for repositories (default: "repos")
+            output_dirs: Optional dict mapping provider names to custom output directories.
+                                     If not specified, uses each provider's default_output_dir.
+            providers: Optional list of providers to use. If not specified, uses all
+                               registered providers.
     """
     console.print("\n[bold cyan]🔄 nao sync[/bold cyan]\n")
     config = NaoConfig.try_load()
-    if not config:
+    if config is None:
         console.print("[bold red]✗[/bold red] No nao_config.yaml found in current directory")
         console.print("[dim]Run 'nao init' to create a configuration file[/dim]")
         sys.exit(1)
+    # Get project path (current working directory after NaoConfig.try_load)
+    project_path = Path.cwd()
     console.print(f"[dim]Project:[/dim] {config.project_name}")
-    repos_synced = 0
-    if config.repos:
-        repos_path = Path(repos_dir)
-        repos_synced = sync_repositories(config.repos, repos_path)
+    # Use provided providers or default to all registered providers
+    active_providers = providers if providers is not None else get_all_providers()
+    output_dirs = output_dirs or {}
-    db_path = Path(output_dir)
-    datasets_synced, tables_synced = sync_databases(config.databases, db_path)
+    # Run each provider
+    results: list[SyncResult] = []
+    for provider in active_providers:
+        if config is None or not provider.should_sync(config):
+            continue
-    console.print("\n[bold green]✓ Sync Complete[/bold green]\n")
+        # Get output directory (custom or default)
+        output_dir = output_dirs.get(provider.name, provider.default_output_dir)
+        output_path = Path(output_dir)
-    if repos_synced > 0:
-        console.print(f"  [dim]Repositories:[/dim] {repos_synced} synced")
+        # Get items and sync
+        items = provider.get_items(config)
+        result = provider.sync(items, output_path, project_path=project_path)
+        results.append(result)
+    # Print summary
+    console.print("\n[bold green]✓ Sync Complete[/bold green]\n")
-    if tables_synced > 0:
-        console.print(f"  [dim]Databases:[/dim] {tables_synced} tables across {datasets_synced} datasets")
+    has_results = False
+    for result in results:
+        if result.items_synced > 0:
+            has_results = True
+            console.print(f"  [dim]{result.provider_name}:[/dim] {result.get_summary()}")
-    if repos_synced == 0 and tables_synced == 0:
+    if not has_results:
         console.print("  [dim]Nothing to sync[/dim]")
     console.print()

nao_core/commands/sync/accessors.py CHANGED Viewed

@@ -1,13 +1,28 @@
 """Data accessor classes for generating markdown documentation from database tables."""
-import json
 from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
 from ibis import BaseBackend
+from nao_core.templates import get_template_engine
 class DataAccessor(ABC):
-    """Base class for data accessors that generate markdown files for tables."""
+    """Base class for data accessors that generate markdown files for tables.
+    Accessors use Jinja2 templates for generating output. Default templates
+    are shipped with nao and can be overridden by users by placing templates
+    with the same name in their project's `templates/` directory.
+    Example:
+        To override the preview template, create:
+        `<project_root>/templates/databases/preview.md.j2`
+    """
+    # Path to the nao project root (set by sync provider)
+    _project_path: Path | None = None
     @property
     @abstractmethod
@@ -15,24 +30,57 @@ class DataAccessor(ABC):
         """The filename this accessor writes to (e.g., 'columns.md')."""
         ...
+    @property
     @abstractmethod
-    def generate(self, conn: BaseBackend, dataset: str, table: str) -> str:
-        """Generate the markdown content for a table.
+    def template_name(self) -> str:
+        """The template file to use (e.g., 'databases/columns.md.j2')."""
+        ...
+    @abstractmethod
+    def get_context(self, conn: BaseBackend, dataset: str, table: str) -> dict[str, Any]:
+        """Get the template context for rendering.
         Args:
-                conn: The Ibis database connection
-                dataset: The dataset/schema name
-                table: The table name
+            conn: The Ibis database connection
+            dataset: The dataset/schema name
+            table: The table name
         Returns:
-                Markdown string content
+            Dictionary of variables to pass to the template
         """
         ...
+    def generate(self, conn: BaseBackend, dataset: str, table: str) -> str:
+        """Generate the markdown content for a table using templates.
+        Args:
+            conn: The Ibis database connection
+            dataset: The dataset/schema name
+            table: The table name
+        Returns:
+            Markdown string content
+        """
+        try:
+            context = self.get_context(conn, dataset, table)
+            engine = get_template_engine(self._project_path)
+            return engine.render(self.template_name, **context)
+        except Exception as e:
+            return f"# {table}\n\nError generating content: {e}"
     def get_table(self, conn: BaseBackend, dataset: str, table: str):
         """Helper to get an Ibis table reference."""
         return conn.table(table, database=dataset)
+    @classmethod
+    def set_project_path(cls, path: Path | None) -> None:
+        """Set the project path for template resolution.
+        Args:
+            path: Path to the nao project root
+        """
+        cls._project_path = path
 def truncate_middle(text: str, max_length: int) -> str:
     """Truncate text in the middle if it exceeds max_length."""
@@ -43,7 +91,14 @@ def truncate_middle(text: str, max_length: int) -> str:
 class ColumnsAccessor(DataAccessor):
-    """Generates columns.md with column names, types, and nullable info."""
+    """Generates columns.md with column names, types, and nullable info.
+    Template variables:
+        - table_name: Name of the table
+        - dataset: Schema/dataset name
+        - columns: List of dicts with 'name', 'type', 'nullable', 'description'
+        - column_count: Total number of columns
+    """
     def __init__(self, max_description_length: int = 256):
         self.max_description_length = max_description_length
@@ -52,37 +107,43 @@ class ColumnsAccessor(DataAccessor):
     def filename(self) -> str:
         return "columns.md"
-    def generate(self, conn: BaseBackend, dataset: str, table: str) -> str:
-        try:
-            t = self.get_table(conn, dataset, table)
-            schema = t.schema()
-            columns = list(schema.items())
-            lines = [
-                f"# {table}",
-                "",
-                f"**Dataset:** `{dataset}`",
-                "",
-                f"## Columns ({len(columns)})",
-                "",
-            ]
-            for name, dtype in columns:
-                description = None
-                parts = [str(dtype)]
-                if description:
-                    truncated = truncate_middle(description, self.max_description_length)
-                    parts.append(f'"{truncated}"')
-                lines.append(f"- {name} ({', '.join(parts)})")
-            return "\n".join(lines)
-        except Exception as e:
-            print(e)
-            return f"# {table}\n\nError fetching schema: {e}"
+    @property
+    def template_name(self) -> str:
+        return "databases/columns.md.j2"
+    def get_context(self, conn: BaseBackend, dataset: str, table: str) -> dict[str, Any]:
+        t = self.get_table(conn, dataset, table)
+        schema = t.schema()
+        columns = []
+        for name, dtype in schema.items():
+            columns.append(
+                {
+                    "name": name,
+                    "type": str(dtype),
+                    "nullable": dtype.nullable if hasattr(dtype, "nullable") else True,
+                    "description": None,  # Could be populated from metadata
+                }
+            )
+        return {
+            "table_name": table,
+            "dataset": dataset,
+            "columns": columns,
+            "column_count": len(columns),
+        }
 class PreviewAccessor(DataAccessor):
-    """Generates preview.md with the first N rows of data as JSONL."""
+    """Generates preview.md with the first N rows of data as JSONL.
+    Template variables:
+        - table_name: Name of the table
+        - dataset: Schema/dataset name
+        - rows: List of row dictionaries
+        - row_count: Number of preview rows
+        - columns: List of column info dicts
+    """
     def __init__(self, num_rows: int = 10):
         self.num_rows = num_rows
@@ -91,121 +152,139 @@ class PreviewAccessor(DataAccessor):
     def filename(self) -> str:
         return "preview.md"
-    def generate(self, conn: BaseBackend, dataset: str, table: str) -> str:
-        try:
-            t = self.get_table(conn, dataset, table)
-            preview_df = t.limit(self.num_rows).execute()
-            lines = [
-                f"# {table} - Preview",
-                "",
-                f"**Dataset:** `{dataset}`",
-                "",
-                f"## Rows ({len(preview_df)})",
-                "",
-            ]
-            for _, row in preview_df.iterrows():
-                row_dict = row.to_dict()
-                # Convert non-serializable types to strings
-                for key, val in row_dict.items():
-                    if val is not None and not isinstance(val, (str, int, float, bool, list, dict)):
-                        row_dict[key] = str(val)
-                lines.append(f"- {json.dumps(row_dict)}")
-            return "\n".join(lines)
-        except Exception as e:
-            return f"# {table} - Preview\n\nError fetching preview: {e}"
+    @property
+    def template_name(self) -> str:
+        return "databases/preview.md.j2"
+    def get_context(self, conn: BaseBackend, dataset: str, table: str) -> dict[str, Any]:
+        t = self.get_table(conn, dataset, table)
+        schema = t.schema()
+        preview_df = t.limit(self.num_rows).execute()
+        rows = []
+        for _, row in preview_df.iterrows():
+            row_dict = row.to_dict()
+            # Convert non-serializable types to strings
+            for key, val in row_dict.items():
+                if val is not None and not isinstance(val, (str, int, float, bool, list, dict)):
+                    row_dict[key] = str(val)
+            rows.append(row_dict)
+        columns = [{"name": name, "type": str(dtype)} for name, dtype in schema.items()]
+        return {
+            "table_name": table,
+            "dataset": dataset,
+            "rows": rows,
+            "row_count": len(rows),
+            "columns": columns,
+        }
 class DescriptionAccessor(DataAccessor):
-    """Generates description.md with table metadata (row count, column count, etc.)."""
+    """Generates description.md with table metadata (row count, column count, etc.).
+    Template variables:
+        - table_name: Name of the table
+        - dataset: Schema/dataset name
+        - row_count: Total rows in the table
+        - column_count: Number of columns
+        - description: Table description (if available)
+        - columns: List of column info dicts
+    """
     @property
     def filename(self) -> str:
         return "description.md"
-    def generate(self, conn: BaseBackend, dataset: str, table: str) -> str:
-        try:
-            t = self.get_table(conn, dataset, table)
-            schema = t.schema()
-            row_count = t.count().execute()
-            col_count = len(schema)
-            lines = [
-                f"# {table}",
-                "",
-                f"**Dataset:** `{dataset}`",
-                "",
-                "## Table Metadata",
-                "",
-                "| Property | Value |",
-                "|----------|-------|",
-                f"| **Row Count** | {row_count:,} |",
-                f"| **Column Count** | {col_count} |",
-                "",
-                "## Description",
-                "",
-                "_No description available._",
-                "",
-            ]
-            return "\n".join(lines)
-        except Exception as e:
-            return f"# {table}\n\nError fetching description: {e}"
+    @property
+    def template_name(self) -> str:
+        return "databases/description.md.j2"
+    def get_context(self, conn: BaseBackend, dataset: str, table: str) -> dict[str, Any]:
+        t = self.get_table(conn, dataset, table)
+        schema = t.schema()
+        row_count = t.count().execute()
+        columns = [{"name": name, "type": str(dtype)} for name, dtype in schema.items()]
+        return {
+            "table_name": table,
+            "dataset": dataset,
+            "row_count": row_count,
+            "column_count": len(schema),
+            "description": None,  # Could be populated from metadata
+            "columns": columns,
+        }
 class ProfilingAccessor(DataAccessor):
-    """Generates profiling.md with column statistics and data profiling."""
+    """Generates profiling.md with column statistics and data profiling.
+    Template variables:
+        - table_name: Name of the table
+        - dataset: Schema/dataset name
+        - column_stats: List of dicts with stats for each column:
+            - name: Column name
+            - type: Data type
+            - null_count: Number of nulls
+            - unique_count: Number of unique values
+            - min_value: Min value (numeric/temporal)
+            - max_value: Max value (numeric/temporal)
+            - error: Error message if stats couldn't be computed
+        - columns: List of column info dicts
+    """
     @property
     def filename(self) -> str:
         return "profiling.md"
-    def generate(self, conn: BaseBackend, dataset: str, table: str) -> str:
-        try:
-            t = self.get_table(conn, dataset, table)
-            schema = t.schema()
-            lines = [
-                f"# {table} - Profiling",
-                "",
-                f"**Dataset:** `{dataset}`",
-                "",
-                "## Column Statistics",
-                "",
-                "| Column | Type | Nulls | Unique | Min | Max |",
-                "|--------|------|-------|--------|-----|-----|",
-            ]
-            for name, dtype in schema.items():
-                col = t[name]
-                dtype_str = str(dtype)
-                try:
-                    null_count = t.filter(col.isnull()).count().execute()
-                    unique_count = col.nunique().execute()
-                    min_val = ""
-                    max_val = ""
-                    if dtype.is_numeric() or dtype.is_temporal():
-                        try:
-                            min_val = str(col.min().execute())
-                            max_val = str(col.max().execute())
-                            if len(min_val) > 20:
-                                min_val = min_val[:17] + "..."
-                            if len(max_val) > 20:
-                                max_val = max_val[:17] + "..."
-                        except Exception:
-                            pass
-                    lines.append(
-                        f"| `{name}` | `{dtype_str}` | {null_count:,} | {unique_count:,} | {min_val} | {max_val} |"
-                    )
-                except Exception as col_error:
-                    lines.append(f"| `{name}` | `{dtype_str}` | Error: {col_error} | | | |")
-            return "\n".join(lines)
-        except Exception as e:
-            return f"# {table} - Profiling\n\nError fetching profiling: {e}"
+    @property
+    def template_name(self) -> str:
+        return "databases/profiling.md.j2"
+    def get_context(self, conn: BaseBackend, dataset: str, table: str) -> dict[str, Any]:
+        t = self.get_table(conn, dataset, table)
+        schema = t.schema()
+        column_stats = []
+        columns = []
+        for name, dtype in schema.items():
+            columns.append({"name": name, "type": str(dtype)})
+            col = t[name]
+            dtype_str = str(dtype)
+            stat = {
+                "name": name,
+                "type": dtype_str,
+                "null_count": 0,
+                "unique_count": 0,
+                "min_value": None,
+                "max_value": None,
+                "error": None,
+            }
+            try:
+                stat["null_count"] = t.filter(col.isnull()).count().execute()
+                stat["unique_count"] = col.nunique().execute()
+                if dtype.is_numeric() or dtype.is_temporal():
+                    try:
+                        min_val = str(col.min().execute())
+                        max_val = str(col.max().execute())
+                        stat["min_value"] = truncate_middle(min_val, 20)
+                        stat["max_value"] = truncate_middle(max_val, 20)
+                    except Exception:
+                        pass
+            except Exception as col_error:
+                stat["error"] = str(col_error)
+            column_stats.append(stat)
+        return {
+            "table_name": table,
+            "dataset": dataset,
+            "column_stats": column_stats,
+            "columns": columns,
+        }

nao-core 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl

nao-core 0.0.30py3-none-any.whl → 0.0.31py3-none-any.whl