nb-fabric 0.2.0

CLI for managing Microsoft Fabric notebooks; create, edit cells, execute interactively, schedule, and query OneLake data
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// #region Imports
use anyhow::Result;
use reqwest::Client;
use serde_json::json;

use crate::client;
use crate::notebook;
// #endregion

// #region Functions

/// Handle `nb create <workspace/name>` command.
/// Creates a new notebook with the specified kernel and optional lakehouse/warehouse bindings.
///
/// Inputs:
///   - reference: "workspace/notebook-name" format
///   - kernel: "python" or "pyspark"
///   - lakehouse: optional lakehouse display name to attach
///   - warehouse: optional warehouse display name to attach
pub async fn run_create(
    http: &Client,
    reference: &str,
    kernel: &str,
    lakehouse: Option<&str>,
    warehouse: Option<&str>,
) -> Result<()> {
    let (ws_name, nb_name) = client::parse_ref(reference)?;
    let ws_id = client::resolve_workspace(http, ws_name).await?;

    // Resolve lakehouse if specified
    let mut lh_id = None;
    let mut lh_name_resolved = None;
    if let Some(lh) = lakehouse {
        let item = client::resolve_item(http, &ws_id, lh, "Lakehouse").await?;
        lh_id = Some(item.id);
        lh_name_resolved = Some(item.display_name);
    }

    // Resolve warehouse if specified
    let mut wh_id = None;
    let mut wh_name_resolved = None;
    if let Some(wh) = warehouse {
        let item = client::resolve_item(http, &ws_id, wh, "Warehouse").await?;
        wh_id = Some(item.id);
        wh_name_resolved = Some(item.display_name);
    }

    let (_, encoded) = notebook::generate_ipynb(
        kernel,
        lh_id.as_deref(),
        lh_name_resolved.as_deref(),
        wh_id.as_deref(),
        wh_name_resolved.as_deref(),
        &ws_id,
    );

    let body = json!({
        "displayName": nb_name,
        "type": "Notebook",
        "definition": {
            "format": "ipynb",
            "parts": [
                {
                    "path": "notebook-content.ipynb",
                    "payload": encoded,
                    "payloadType": "InlineBase64"
                }
            ]
        }
    });

    let item = client::create_item(http, &ws_id, &body).await?;

    println!("  Created notebook");
    println!("  {}", "-".repeat(40));
    println!("  Name        {}", item.display_name);
    println!("  ID          {}", item.id);
    println!("  Workspace   {}", ws_id);
    println!("  Kernel      {}", kernel);

    if let Some(ref lh) = lh_name_resolved {
        println!("  Lakehouse   {}", lh);
    }
    if let Some(ref wh) = wh_name_resolved {
        println!("  Warehouse   {}", wh);
    }

    Ok(())
}

// #endregion