sqlmesh 0.186.2.dev10__tar.gz → 0.186.2.dev11__tar.gz

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.186.2.dev10
+Version: 0.186.2.dev11
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.186.2.dev10'
-__version_tuple__ = version_tuple = (0, 186, 2, 'dev10')
+__version__ = version = '0.186.2.dev11'
+__version_tuple__ = version_tuple = (0, 186, 2, 'dev11')

sqlmesh-0.186.2.dev11/sqlmesh/lsp/context.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from pathlib import Path
+from sqlmesh.core.context import Context
+import typing as t
+
+from sqlmesh.core.model.definition import SqlModel
+from sqlmesh.lsp.custom import RenderModelEntry
+from sqlmesh.lsp.uri import URI
+
+
+@dataclass
+class ModelTarget:
+    """Information about models in a file."""
+
+    names: t.List[str]
+
+
+@dataclass
+class AuditTarget:
+    """Information about standalone audits in a file."""
+
+    name: str
+
+
+class LSPContext:
+    """
+    A context that is used for linting. It contains the context and a reverse map of file uri to
+    model names and standalone audit names.
+    """
+
+    def __init__(self, context: Context) -> None:
+        self.context = context
+
+        # Add models to the map
+        model_map: t.Dict[Path, ModelTarget] = {}
+        for model in context.models.values():
+            if model._path is not None:
+                uri = model._path
+                if uri in model_map:
+                    model_map[uri].names.append(model.name)
+                else:
+                    model_map[uri] = ModelTarget(names=[model.name])
+
+        # Add standalone audits to the map
+        audit_map: t.Dict[Path, AuditTarget] = {}
+        for audit in context.standalone_audits.values():
+            if audit._path is not None:
+                uri = audit._path
+                if uri not in audit_map:
+                    audit_map[uri] = AuditTarget(name=audit.name)
+
+        self.map: t.Dict[Path, t.Union[ModelTarget, AuditTarget]] = {
+            **model_map,
+            **audit_map,
+        }
+
+
+def render_model(context: LSPContext, uri: URI) -> t.Iterator[RenderModelEntry]:
+    target = context.map[uri.to_path()]
+    if isinstance(target, AuditTarget):
+        audit = context.context.standalone_audits[target.name]
+        definition = audit.render_definition(
+            include_python=False,
+            render_query=True,
+        )
+        rendered_query = [render.sql(dialect=audit.dialect, pretty=True) for render in definition]
+        yield RenderModelEntry(
+            name=audit.name,
+            fqn=audit.fqn,
+            description=audit.description,
+            rendered_query="\n\n".join(rendered_query),
+        )
+    if isinstance(target, ModelTarget):
+        for name in target.names:
+            model = context.context.get_model(name)
+            if isinstance(model, SqlModel):
+                rendered_query = [
+                    render.sql(dialect=model.dialect, pretty=True)
+                    for render in model.render_definition(
+                        include_python=False,
+                        render_query=True,
+                    )
+                ]
+                yield RenderModelEntry(
+                    name=model.name,
+                    fqn=model.fqn,
+                    description=model.description,
+                    rendered_query="\n\n".join(rendered_query),
+                )

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/sqlmesh/lsp/custom.py

@@ -20,3 +20,29 @@ class AllModelsResponse(PydanticModel):
 
     models: t.List[str]
     keywords: t.List[str]
+
+
+RENDER_MODEL_FEATURE = "sqlmesh/render_model"
+
+
+class RenderModelRequest(PydanticModel):
+    textDocumentUri: str
+
+
+class RenderModelEntry(PydanticModel):
+    """
+    An entry in the rendered model.
+    """
+
+    name: str
+    fqn: str
+    description: str
+    rendered_query: str
+
+
+class RenderModelResponse(PydanticModel):
+    """
+    Response to render a model.
+    """
+
+    models: t.List[RenderModelEntry]

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/sqlmesh/lsp/main.py

@@ -20,8 +20,15 @@ from sqlmesh.lsp.api import (
     ApiResponseGetModels,
 )
 from sqlmesh.lsp.completions import get_sql_completions
-from sqlmesh.lsp.context import LSPContext, ModelTarget
-from sqlmesh.lsp.custom import ALL_MODELS_FEATURE, AllModelsRequest, AllModelsResponse
+from sqlmesh.lsp.context import LSPContext, ModelTarget, render_model as render_model_context
+from sqlmesh.lsp.custom import (
+    ALL_MODELS_FEATURE,
+    RENDER_MODEL_FEATURE,
+    AllModelsRequest,
+    AllModelsResponse,
+    RenderModelRequest,
+    RenderModelResponse,
+)
 from sqlmesh.lsp.reference import (
     get_references,
 )
@@ -88,6 +95,12 @@ class SQLMeshLanguageServer:
             except Exception as e:
                 return get_sql_completions(None, uri)
 
+        @self.server.feature(RENDER_MODEL_FEATURE)
+        def render_model(ls: LanguageServer, params: RenderModelRequest) -> RenderModelResponse:
+            uri = URI(params.textDocumentUri)
+            context = self._context_get_or_load(uri)
+            return RenderModelResponse(models=list(render_model_context(context, uri)))
+
         @self.server.feature(API_FEATURE)
         def api(ls: LanguageServer, request: ApiRequest) -> t.Dict[str, t.Any]:
             ls.log_trace(f"API request: {request}")

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.186.2.dev10
+Version: 0.186.2.dev11
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/sqlmesh.egg-info/SOURCES.txt

@@ -689,6 +689,7 @@ vscode/extension/scripts/fetch-vscode.ts
 vscode/extension/src/extension.ts
 vscode/extension/src/auth/auth.ts
 vscode/extension/src/commands/format.ts
+vscode/extension/src/commands/renderModel.ts
 vscode/extension/src/commands/signin.ts
 vscode/extension/src/commands/signinSpecifyFlow.ts
 vscode/extension/src/commands/signout.ts
@@ -711,6 +712,8 @@ vscode/extension/src/utilities/common/vscodeapi.ts
 vscode/extension/src/utilities/sqlmesh/sqlmesh.ts
 vscode/extension/src/webviews/lineagePanel.ts
 vscode/extension/tests/lineage.spec.ts
+vscode/extension/tests/render.spec.ts
+vscode/extension/tests/utils.ts
 vscode/react/.cta.json
 vscode/react/.gitignore
 vscode/react/index.html

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/vscode/extension/package.json

@@ -87,8 +87,23 @@
         "command": "sqlmesh.signout",
         "title": "Sign out from Tobiko Cloud",
         "description": "SQLMesh"
+      },
+      {
+        "command": "sqlmesh.renderModel",
+        "title": "Render Model",
+        "description": "Render the model in the current editor",
+        "icon": "$(open-preview)"
       }
-    ]
+    ],
+    "menus": {
+      "editor/title": [
+        {
+          "command": "sqlmesh.renderModel",
+          "when": "resourceExtname == .sql",
+          "group": "navigation"
+        }
+      ]
+    }
   },
   "scripts": {
     "ci": "pnpm run lint && pnpm run compile",

sqlmesh-0.186.2.dev11/vscode/extension/src/commands/renderModel.ts

@@ -0,0 +1,90 @@
+import * as vscode from 'vscode'
+import { LSPClient } from '../lsp/lsp'
+import { isErr } from '@bus/result'
+import { RenderModelEntry } from '../lsp/custom'
+
+export function renderModel(lspClient?: LSPClient) {
+  return async () => {
+    // Get the current active editor
+    const activeEditor = vscode.window.activeTextEditor
+
+    if (!activeEditor) {
+      vscode.window.showErrorMessage('No active editor found')
+      return
+    }
+
+    if (!lspClient) {
+      vscode.window.showErrorMessage('LSP client not available')
+      return
+    }
+
+    // Get the current document URI
+    const documentUri = activeEditor.document.uri.toString(true)
+
+    // Call the render model API
+    const result = await lspClient.call_custom_method('sqlmesh/render_model', {
+      textDocumentUri: documentUri,
+    })
+
+    if (isErr(result)) {
+      vscode.window.showErrorMessage(`Failed to render model: ${result.error}`)
+      return
+    }
+
+    // Check if we got any models
+    if (!result.value.models || result.value.models.length === 0) {
+      vscode.window.showInformationMessage(
+        'No models found in the current file',
+      )
+      return
+    }
+
+    // If multiple models, let user choose
+    let selectedModel: RenderModelEntry
+    if (result.value.models.length > 1) {
+      const items = result.value.models.map((model: RenderModelEntry) => ({
+        label: model.name,
+        description: model.fqn,
+        detail: model.description,
+        model: model,
+      }))
+
+      const selected = await vscode.window.showQuickPick(items, {
+        placeHolder: 'Select a model to render',
+      })
+
+      if (!selected) {
+        return
+      }
+
+      selectedModel = selected.model
+    } else {
+      selectedModel = result.value.models[0]
+    }
+
+    // Create a new untitled document with the rendered SQL
+    const document = await vscode.workspace.openTextDocument({
+      language: 'sql',
+      content: selectedModel.rendered_query,
+    })
+
+    // Determine the view column for side-by-side display
+    let viewColumn: vscode.ViewColumn
+    if (activeEditor) {
+      // Open beside the current editor
+      viewColumn = activeEditor.viewColumn
+        ? activeEditor.viewColumn + 1
+        : vscode.ViewColumn.Two
+    } else {
+      // If no active editor, open in column two
+      viewColumn = vscode.ViewColumn.Two
+    }
+
+    // Open the document in the editor as a preview (preview: true is default)
+    await vscode.window.showTextDocument(document, {
+      viewColumn: viewColumn,
+      preview: true,
+      preserveFocus: false,
+    })
+  }
+}

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/vscode/extension/src/extension.ts

@@ -12,6 +12,7 @@ import { AuthenticationProviderTobikoCloud } from './auth/auth'
 import { signOut } from './commands/signout'
 import { signIn } from './commands/signin'
 import { signInSpecifyFlow } from './commands/signinSpecifyFlow'
+import { renderModel } from './commands/renderModel'
 import { isErr } from '@bus/result'
 import {
   handleNotSginedInError,
@@ -64,6 +65,13 @@ export async function activate(context: vscode.ExtensionContext) {
 
   lspClient = new LSPClient()
 
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'sqlmesh.renderModel',
+      renderModel(lspClient),
+    ),
+  )
+
   context.subscriptions.push(
     vscode.languages.registerCompletionItemProvider(
       selector,

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/vscode/extension/src/lsp/custom.ts

@@ -4,8 +4,32 @@ export interface AllModelsMethod {
   response: AllModelsResponse
 }
 
+export interface RenderModelMethod {
+  method: 'sqlmesh/render_model'
+  request: RenderModelRequest
+  response: RenderModelResponse
+}
+
+interface RenderModelRequest {
+  textDocumentUri: string
+}
+
+interface RenderModelResponse {
+  models: RenderModelEntry[]
+}
+
+export interface RenderModelEntry {
+  name: string
+  fqn: string
+  description: string
+  rendered_query: string
+}
+
 // @eslint-disable-next-line  @typescript-eslint/consistent-type-definition
-export type CustomLSPMethods = AllModelsMethod | AbstractAPICall
+export type CustomLSPMethods =
+  | AllModelsMethod
+  | AbstractAPICall
+  | RenderModelMethod
 
 interface AllModelsRequest {
   textDocument: {

{sqlmesh-0.186.2.dev10 → sqlmesh-0.186.2.dev11}/vscode/extension/tests/lineage.spec.ts

@@ -2,13 +2,8 @@ import { test, _electron as electron, expect, ElectronApplication, Page } from '
 import path from 'path';
 import fs from 'fs-extra';
 import os from 'os';
+import { startVSCode, SUSHI_SOURCE_PATH } from './utils';
 
-// Absolute path to the VS Code executable you downloaded in step 1.
-const VS_CODE_EXE = fs.readJsonSync('.vscode-test/paths.json').executablePath;
-// Where your extension lives on disk
-const EXT_PATH = path.resolve(__dirname, '..');
-// Where the sushi project lives which we copy from
-const SUSHI_SOURCE_PATH = path.join(__dirname, '..', '..', '..', 'examples', 'sushi');
 
 /**
  * Helper function to launch VS Code and test lineage with given project path config
@@ -26,44 +21,6 @@ async function testLineageWithProjectPath(
     await expect(loadedContextText.first()).toBeVisible({ timeout: 10_000 });
 }
 
-/**
- * Launch VS Code and return the window and a function to close the app.
- * @param workspaceDir The workspace directory to open.
- * @returns The window and a function to close the app.
- */
-export const startVSCode = async (workspaceDir: string): Promise<{
-  window: Page,
-  close: () => Promise<void>,
-}> => {
-  const userDataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-user-data-'));
-  const ciArgs = process.env.CI ? [
-    '--disable-gpu',
-    '--headless',
-    '--no-sandbox',
-    '--disable-dev-shm-usage',
-    '--window-position=-10000,0',
-  ] : [];
-  const args = [
-    ...ciArgs,
-    `--extensionDevelopmentPath=${EXT_PATH}`,
-    '--disable-workspace-trust',
-    '--disable-telemetry',
-    `--user-data-dir=${userDataDir}`,
-    workspaceDir,
-  ];
-  const electronApp = await electron.launch({
-    executablePath: VS_CODE_EXE,
-    args,
-  });
-  const window = await electronApp.firstWindow();
-  await window.waitForLoadState('domcontentloaded');
-  await window.waitForLoadState('networkidle');
-  await window.waitForTimeout(2_000);
-  return { window, close: async () => {
-    await electronApp.close();
-    await fs.remove(userDataDir);
-  } };
-}
 
 test('Lineage panel renders correctly - no project path config (default)', async () => {
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-sushi-'));

sqlmesh-0.186.2.dev11/vscode/extension/tests/render.spec.ts

@@ -0,0 +1,38 @@
+import { test, expect } from '@playwright/test';
+import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
+import { startVSCode, SUSHI_SOURCE_PATH } from './utils';
+
+test('Render works correctly', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-sushi-'));
+    await fs.copy(SUSHI_SOURCE_PATH, tempDir);
+
+    try {
+      const { window, close } = await startVSCode(tempDir);
+
+      //   Wait for the models folder to be visible
+      await window.waitForSelector('text=models');
+
+      // Click on the models folder, excluding external_models
+      await window.getByRole('treeitem', { name: 'models', exact: true }).locator('a').click();
+
+      // Open the customer_revenue_lifetime model
+      await window.getByRole('treeitem', { name: 'customers.sql', exact: true }).locator('a').click();
+
+      await window.waitForSelector('text=grain');
+      await window.waitForSelector('text=Loaded SQLMesh Context')
+
+      // Render the model
+      await window.keyboard.press(process.platform === 'darwin' ? 'Meta+Shift+P' : 'Control+Shift+P');
+      await window.keyboard.type('Render Model');
+      await window.keyboard.press('Enter');
+
+      // Check if the model is rendered by check if "`oi`.`order_id` AS `order_id`," is in the window
+      await expect(window.locator('text="marketing"."customer_id" AS')).toBeVisible();
+
+      await close();
+    } finally {
+      await fs.remove(tempDir);
+    }
+  });

sqlmesh-0.186.2.dev11/vscode/extension/tests/utils.ts

@@ -0,0 +1,50 @@
+import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
+import { _electron as electron, Page } from '@playwright/test';
+
+// Absolute path to the VS Code executable you downloaded in step 1.
+export const VS_CODE_EXE = fs.readJsonSync('.vscode-test/paths.json').executablePath;
+// Where your extension lives on disk
+export const EXT_PATH = path.resolve(__dirname, '..');
+// Where the sushi project lives which we copy from
+export const SUSHI_SOURCE_PATH = path.join(__dirname, '..', '..', '..', 'examples', 'sushi');
+
+/**
+ * Launch VS Code and return the window and a function to close the app.
+ * @param workspaceDir The workspace directory to open.
+ * @returns The window and a function to close the app.
+ */
+export const startVSCode = async (workspaceDir: string): Promise<{
+    window: Page,
+    close: () => Promise<void>,
+  }> => {
+    const userDataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-user-data-'));
+    const ciArgs = process.env.CI ? [
+      '--disable-gpu',
+      '--headless',
+      '--no-sandbox',
+      '--disable-dev-shm-usage',
+      '--window-position=-10000,0',
+    ] : [];
+    const args = [
+      ...ciArgs,
+      `--extensionDevelopmentPath=${EXT_PATH}`,
+      '--disable-workspace-trust',
+      '--disable-telemetry',
+      `--user-data-dir=${userDataDir}`,
+      workspaceDir,
+    ];
+    const electronApp = await electron.launch({
+      executablePath: VS_CODE_EXE,
+      args,
+    });
+    const window = await electronApp.firstWindow();
+    await window.waitForLoadState('domcontentloaded');
+    await window.waitForLoadState('networkidle');
+    await window.waitForTimeout(2_000);
+    return { window, close: async () => {
+      await electronApp.close();
+      await fs.remove(userDataDir);
+    } };
+  }

sqlmesh-0.186.2.dev10/sqlmesh/lsp/context.py

@@ -1,51 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from sqlmesh.core.context import Context
-import typing as t
-
-
-@dataclass
-class ModelTarget:
-    """Information about models in a file."""
-
-    names: t.List[str]
-
-
-@dataclass
-class AuditTarget:
-    """Information about standalone audits in a file."""
-
-    name: str
-
-
-class LSPContext:
-    """
-    A context that is used for linting. It contains the context and a reverse map of file uri to
-    model names and standalone audit names.
-    """
-
-    def __init__(self, context: Context) -> None:
-        self.context = context
-
-        # Add models to the map
-        model_map: t.Dict[Path, ModelTarget] = {}
-        for model in context.models.values():
-            if model._path is not None:
-                uri = model._path
-                if uri in model_map:
-                    model_map[uri].names.append(model.name)
-                else:
-                    model_map[uri] = ModelTarget(names=[model.name])
-
-        # Add standalone audits to the map
-        audit_map: t.Dict[Path, AuditTarget] = {}
-        for audit in context.standalone_audits.values():
-            if audit._path is not None:
-                uri = audit._path
-                if uri not in audit_map:
-                    audit_map[uri] = AuditTarget(name=audit.name)
-
-        self.map: t.Dict[Path, t.Union[ModelTarget, AuditTarget]] = {
-            **model_map,
-            **audit_map,
-        }