sqlmesh 0.188.2.dev12__tar.gz → 0.188.2.dev14__tar.gz

{sqlmesh-0.188.2.dev12 → sqlmesh-0.188.2.dev14}/PKG-INFO

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

{sqlmesh-0.188.2.dev12 → sqlmesh-0.188.2.dev14}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.188.2.dev12'
-__version_tuple__ = version_tuple = (0, 188, 2, 'dev12')
+__version__ = version = '0.188.2.dev14'
+__version_tuple__ = version_tuple = (0, 188, 2, 'dev14')

{sqlmesh-0.188.2.dev12 → sqlmesh-0.188.2.dev14}/sqlmesh.egg-info/PKG-INFO

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

{sqlmesh-0.188.2.dev12 → sqlmesh-0.188.2.dev14}/tests/web/test_main.py

@@ -106,6 +106,18 @@ def test_write_file(client: TestClient, project_tmp_path: Path) -> None:
     }
 
 
+def test_write_file_non_ascii(client: TestClient, project_tmp_path: Path) -> None:
+    response = client.post("/api/files/foo.txt", json={"content": "何か良いこと"})
+    file = _get_file_with_content(project_tmp_path / "foo.txt", "foo.txt")
+    assert response.status_code == 204
+    assert file.dict() == {
+        "name": "foo.txt",
+        "path": "foo.txt",
+        "extension": ".txt",
+        "content": "何か良いこと",
+    }
+
+
 def test_update_file(client: TestClient, project_tmp_path: Path) -> None:
     txt_file = project_tmp_path / "foo.txt"
     txt_file.write_text("bar")
@@ -212,7 +224,12 @@ def test_create_directory(client: TestClient, project_tmp_path: Path) -> None:
     response = client.post("/api/directories/new_dir")
     assert response.status_code == 200
     assert (project_tmp_path / "new_dir").exists()
-    assert response.json() == {"directories": [], "files": [], "name": "new_dir", "path": "new_dir"}
+    assert response.json() == {
+        "directories": [],
+        "files": [],
+        "name": "new_dir",
+        "path": "new_dir",
+    }
 
 
 def test_create_directory_already_exists(client: TestClient, project_tmp_path: Path) -> None:
@@ -494,7 +511,9 @@ def test_delete_environment_failure(
     client: TestClient, web_sushi_context: Context, mocker: MockerFixture
 ):
     mocker.patch.object(
-        web_sushi_context.state_sync, "invalidate_environment", side_effect=Exception("Some error")
+        web_sushi_context.state_sync,
+        "invalidate_environment",
+        side_effect=Exception("Some error"),
     )
 
     response = client.delete("/api/environments/test")

{sqlmesh-0.188.2.dev12 → sqlmesh-0.188.2.dev14}/vscode/extension/src/commands/renderModel.ts

@@ -4,6 +4,51 @@ import { isErr } from '@bus/result'
 import { RenderModelEntry } from '../lsp/custom'
 import { RenderedModelProvider } from '../providers/renderedModelProvider'
 
+export async function reRenderModelForSourceFile(
+  sourceUri: string,
+  lspClient: LSPClient,
+  renderedModelProvider: RenderedModelProvider,
+): Promise<void> {
+  const renderedUri = renderedModelProvider.getRenderedUriForSource(sourceUri)
+  if (!renderedUri) {
+    return // No rendered model exists for this source file
+  }
+
+  // Call the render model API
+  const result = await lspClient.call_custom_method('sqlmesh/render_model', {
+    textDocumentUri: sourceUri,
+  })
+
+  if (isErr(result)) {
+    // Silently fail on auto-rerender errors to avoid spamming user
+    return
+  }
+
+  // Check if we got any models
+  if (!result.value.models || result.value.models.length === 0) {
+    return
+  }
+
+  // Get the originally rendered model information
+  const originalModelInfo =
+    renderedModelProvider.getModelInfoForRendered(renderedUri)
+
+  // Find the specific model that was originally rendered, or fall back to the first model
+  const selectedModel = originalModelInfo
+    ? result.value.models.find(
+        model =>
+          model.name === originalModelInfo.name &&
+          model.fqn === originalModelInfo.fqn,
+      ) || result.value.models[0]
+    : result.value.models[0]
+
+  // Update the existing rendered model content
+  renderedModelProvider.updateRenderedModel(
+    renderedUri,
+    selectedModel.rendered_query,
+  )
+}
+
 export function renderModel(
   lspClient?: LSPClient,
   renderedModelProvider?: RenderedModelProvider,
@@ -114,6 +159,8 @@ export function renderModel(
     const uri = renderedModelProvider.storeRenderedModel(
       selectedModel.name,
       selectedModel.rendered_query,
+      documentUri,
+      selectedModel,
     )
 
     // Open the virtual document

{sqlmesh-0.188.2.dev12 → sqlmesh-0.188.2.dev14}/vscode/extension/src/extension.ts

@@ -12,7 +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 { renderModel, reRenderModelForSourceFile } from './commands/renderModel'
 import { isErr } from '@bus/result'
 import {
   handleNotSginedInError,
@@ -23,6 +23,7 @@ import {
 import { selector, completionProvider } from './completion/completion'
 import { LineagePanel } from './webviews/lineagePanel'
 import { RenderedModelProvider } from './providers/renderedModelProvider'
+import { sleep } from './utilities/sleep'
 
 let lspClient: LSPClient | undefined
 
@@ -99,6 +100,25 @@ export async function activate(context: vscode.ExtensionContext) {
     ),
   )
 
+  // Add file save listener for auto-rerendering models
+  context.subscriptions.push(
+    vscode.workspace.onDidSaveTextDocument(async document => {
+      if (
+        lspClient &&
+        renderedModelProvider.hasRenderedModelForSource(
+          document.uri.toString(true),
+        )
+      ) {
+        await sleep(100)
+        await reRenderModelForSourceFile(
+          document.uri.toString(true),
+          lspClient,
+          renderedModelProvider,
+        )
+      }
+    }),
+  )
+
   const restart = async () => {
     if (lspClient) {
       traceVerbose('Restarting LSP client')

sqlmesh-0.188.2.dev14/vscode/extension/src/providers/renderedModelProvider.ts

@@ -0,0 +1,141 @@
+import * as vscode from 'vscode'
+import { RenderModelEntry } from '../lsp/custom'
+
+interface RenderedModelInfo {
+  content: string
+  sourceUri?: string
+  modelInfo?: RenderModelEntry
+}
+
+/**
+ * Content provider for read-only rendered SQL models
+ */
+export class RenderedModelProvider
+  implements vscode.TextDocumentContentProvider
+{
+  private static readonly scheme = 'sqlmesh-rendered'
+
+  // Single map containing all rendered model information
+  private renderedModels = new Map<string, RenderedModelInfo>()
+  // Track which source file URIs are associated with rendered models
+  private sourceToRenderedUri = new Map<string, vscode.Uri>()
+
+  // Event emitter for content changes
+  private _onDidChange = new vscode.EventEmitter<vscode.Uri>()
+  readonly onDidChange = this._onDidChange.event
+
+  /**
+   * Provide text content for a given URI
+   */
+  provideTextDocumentContent(uri: vscode.Uri): string {
+    const key = uri.toString()
+    const modelInfo = this.renderedModels.get(key)
+    return modelInfo?.content || ''
+  }
+
+  /**
+   * Store rendered model content and create a URI for it
+   */
+  storeRenderedModel(
+    modelName: string,
+    content: string,
+    sourceUri?: string,
+    modelInfo?: RenderModelEntry,
+  ): vscode.Uri {
+    const fileName = `${modelName} (rendered)`
+    // Add a timestamp to make the URI unique for each render
+    const timestamp = Date.now()
+    // Use vscode.Uri.from for proper URI construction
+    const uri = vscode.Uri.from({
+      scheme: RenderedModelProvider.scheme,
+      path: fileName,
+      fragment: timestamp.toString(),
+    })
+
+    const uriString = uri.toString()
+
+    // Store all information in single map
+    this.renderedModels.set(uriString, {
+      content,
+      sourceUri,
+      modelInfo,
+    })
+
+    // Track the association between a source file and the rendered model
+    if (sourceUri) {
+      // Remove any existing mapping for this source file
+      const existingRenderedUri = this.sourceToRenderedUri.get(sourceUri)
+      if (existingRenderedUri) {
+        this.renderedModels.delete(existingRenderedUri.toString())
+      }
+
+      this.sourceToRenderedUri.set(sourceUri, uri)
+    }
+
+    this._onDidChange.fire(uri)
+    return uri
+  }
+
+  /**
+   * Update an existing rendered model with new content
+   */
+  updateRenderedModel(uri: vscode.Uri, content: string): void {
+    const uriString = uri.toString()
+    const existingInfo = this.renderedModels.get(uriString)
+    if (existingInfo) {
+      this.renderedModels.set(uriString, {
+        ...existingInfo,
+        content,
+      })
+    }
+    this._onDidChange.fire(uri)
+  }
+
+  /**
+   * Get the rendered URI for a given source file URI
+   */
+  getRenderedUriForSource(sourceUri: string): vscode.Uri | undefined {
+    return this.sourceToRenderedUri.get(sourceUri)
+  }
+
+  /**
+   * Get the source URI for a given rendered model URI
+   */
+  getSourceUriForRendered(renderedUri: string): string | undefined {
+    const modelInfo = this.renderedModels.get(renderedUri)
+    return modelInfo?.sourceUri
+  }
+
+  /**
+   * Get the model information for a given rendered model URI
+   */
+  getModelInfoForRendered(
+    renderedUri: vscode.Uri,
+  ): RenderModelEntry | undefined {
+    const modelInfo = this.renderedModels.get(renderedUri.toString())
+    return modelInfo?.modelInfo
+  }
+
+  /**
+   * Check if a source file has an associated rendered model
+   */
+  hasRenderedModelForSource(sourceUri: string): boolean {
+    return this.sourceToRenderedUri.has(sourceUri)
+  }
+
+  /**
+   * Get the URI scheme for rendered models
+   */
+  static getScheme(): string {
+    return this.scheme
+  }
+
+  /**
+   * Clean up old rendered models to prevent memory leaks
+   */
+  dispose() {
+    this.renderedModels.clear()
+    this.sourceToRenderedUri.clear()
+    this._onDidChange.dispose()
+  }
+}

{sqlmesh-0.188.2.dev12 → sqlmesh-0.188.2.dev14}/web/server/api/endpoints/files.py

@@ -168,7 +168,7 @@ def _get_directory(path: str | Path, settings: Settings) -> models.Directory:
 def _get_file_with_content(file_path: Path, relative_path: str) -> models.File:
     """Get a file, including its contents."""
     try:
-        content = file_path.read_text()
+        content = file_path.read_text(encoding="utf-8")
     except FileNotFoundError as e:
         raise e
     except Exception:

sqlmesh-0.188.2.dev12/vscode/extension/src/providers/renderedModelProvider.ts

@@ -1,57 +0,0 @@
-import * as vscode from 'vscode'
-
-/**
- * Content provider for read-only rendered SQL models
- */
-export class RenderedModelProvider
-  implements vscode.TextDocumentContentProvider
-{
-  private static readonly scheme = 'sqlmesh-rendered'
-
-  private renderedModels = new Map<string, string>()
-
-  // Event emitter for content changes
-  private _onDidChange = new vscode.EventEmitter<vscode.Uri>()
-  readonly onDidChange = this._onDidChange.event
-
-  /**
-   * Provide text content for a given URI
-   */
-  provideTextDocumentContent(uri: vscode.Uri): string {
-    const key = uri.toString()
-    return this.renderedModels.get(key) || ''
-  }
-
-  /**
-   * Store rendered model content and create a URI for it
-   */
-  storeRenderedModel(modelName: string, content: string): vscode.Uri {
-    const fileName = `${modelName} (rendered)`
-    // Add a timestamp to make the URI unique for each render
-    const timestamp = Date.now()
-    // Use vscode.Uri.from for proper URI construction
-    const uri = vscode.Uri.from({
-      scheme: RenderedModelProvider.scheme,
-      path: fileName,
-      fragment: timestamp.toString(),
-    })
-    this.renderedModels.set(uri.toString(), content)
-    this._onDidChange.fire(uri)
-    return uri
-  }
-
-  /**
-   * Get the URI scheme for rendered models
-   */
-  static getScheme(): string {
-    return this.scheme
-  }
-
-  /**
-   * Clean up old rendered models to prevent memory leaks
-   */
-  dispose() {
-    this.renderedModels.clear()
-    this._onDidChange.dispose()
-  }
-}