Connection Utils

synutils is the unified entry point in every notebook — a Python attribute and a Scala REPL alias. Each section below lists user-callable methods with examples in both languages.

 

connections — connection metadata + decrypted parameters

Method

Purpose

get(name)

Full connection object (parameters auto-decrypted; encrypted fields wrapped in SecretString)

getParam(name, param)

Single parameter value as str / String (see redaction note below)

getParamSealed(name, param)(Scala only)

Single parameter value as SecretString. Always wrapped — host / port will redact too. Use for .get() / .unseal() ergonomics.

getAllParams(name)

All parameters — preserves SecretString wrapping for encrypted fields

clearCache()

Drop cached responses

Python

 
conn = synutils.connections.get("my_snowflake")
host = synutils.connections.getParam("my_snowflake", "host") 

# Drop cached responses (force a re-fetch on next call) 
synutils.connections.clearCache()

Scala

 
val conn = synutils.connections.get("my_snowflake") 
val host = synutils.connections.getParam("my_snowflake", "host") 

// Drop cached responses (force a re-fetch on next call) 
synutils.connections.clearCache()


Redaction — encrypted fields render as **********

After decryption, encrypted parameter fields (passwords, API keys, secret keys, private keys — whichever fields apply per connection type) are wrapped in SecretString. They redact in print/log output but still work for SDK calls. Non-encrypted parameters (host, port, database, etc.) are returned as plain strings.

Python 

SecretString is a str subclass; it redacts when printed and reveals when you call .get() / .unseal() (or, if a SDK accepts a str subclass directly, you can pass it as-is).

 

conn = synutils.connections.get("my_snowflake") 
print(conn["parameters"]) 
# {'host': 'snow.example.com', 
# 'database': 'analytics', 
# 'username': 'svc_account', 
# 'password': '**********', 
# 'privateKey': '**********'} 

# Plain field — no wrapping 
print(conn["parameters"]["host"]) # snow.example.com 

# Encrypted field — redacts in print, reveals via .get() 
pw = conn["parameters"]["password"] 
print(pw) # ********** 
print(f"pw={pw}")                 # pw=********** 
print(pw.get())                   # actual password 

# Pass to a SDK (works because SecretString is a str subclass — but 
# many SDKs call str() internally, which returns "**********". For those, 
# call .get() explicitly to be safe.) 
import snowflake.connector 
conn_handle = snowflake.connector.connect( 
    user=conn["parameters"]["username"], 
    password=conn["parameters"]["password"].get(),         # <- unseal for SDK 
    account=conn["parameters"]["account"], 
)

Scala 

SecretString has an implicit conversion to String, so JDBC and most SDKs work directly. Use .get() / .unseal() for explicit reveal.

 
val conn = synutils.connections.get("my_snowflake") 
val params = conn("parameters").asInstanceOf[Map[String, Any]] 

println(params) 
// Map(host -> snow.example.com, database -> analytics, 
// username -> svc_account, password -> **********, privateKey -> **********) 

// Encrypted field — pattern-match for type-safe access 
val pwd = params("password").asInstanceOf[SecretString] 
println(pwd)                       // ********** 
println(pwd.get())                 // actual password 

// JDBC — implicit conversion fires automatically (no explicit unseal needed) 
import java.sql.DriverManager 
DriverManager.getConnection(jdbcUrl, "svc_account", pwd) 

// String interpolation — type ascription forces the conversion 
val safeUrl = s"jdbc:postgresql://host/${pwd: String}"