Code Snippets on Cacher

❄️ Snowflake CLIs

# Écosystème CLI Snowflake — carte synthétique

> **TL;DR** : utilise `snow` (Snowflake CLI) comme couteau suisse moderne. Évite `snowsql` (legacy). Garde `snowcd` sous la main pour les debugs réseau corpo. Les autres outils (Snowpark, dbt-snowflake, snowflake-labs-mcp) ne sont **pas** des CLI, mais s'appuient tous sur le même socle Python.

---

## Carte d'ensemble

```
                  ┌─────────────────────────────┐
                  │ snowflake-connector-python  │  ← socle commun moderne

❄️ 🔌 Snowflake - MCP avec GitHub Copilot

# Tutorial Snowflake MCP avec GitHub Copilot — du quickstart à l'avancé

Tutorial pas-à-pas pour démarrer avec **Snowflake-Labs/mcp** (l'implémentation open-source officielle, qui tourne localement) depuis **VS Code + GitHub Copilot Agent Mode**. On part de zéro et on monte en complexité par paliers, avec des checkpoints à chaque niveau.

> **Note** : ce tutorial cible le serveur **local** (`uvx snowflake-labs-mcp`). Pour la version hébergée Snowflake-managed MCP server (GA novembre 2025), la mi

🔌 MCP - GitHub Copilot

# MCP Servers dans GitHub Copilot (VS Code) — guide synthétique

## Philosophie de l'outil

GitHub Copilot adopte une approche **UI-first** : la majorité des opérations passent par la **Command Palette** (`Ctrl+Shift+P`) ou par la **vue Extensions**. Les fichiers de configuration (`mcp.json`) restent éditables à la main, mais l'IDE expose toujours une action graphique équivalente.

**Deux portées (scopes) seulement :**

| Scope | Fichier | Utilité |
|---|---|---|
| **Workspace** | `.vscode/mcp.j

🔌 MCP - Claude Code

# MCP Servers dans Claude Code — guide synthétique

## Philosophie de l'outil

Claude Code adopte une approche **CLI-first** : toute la gestion passe par la sous-commande `claude mcp`, complétée par la slash-command `/mcp` à l'intérieur d'une session. Pas d'interface graphique : tout est explicite et scriptable.

**Trois portées (scopes), à choisir explicitement à l'ajout :**

| Scope | Flag | Fichier | Utilité |
|---|---|---|---|
| **local** (défaut) | `-s local` (implicite) | `~/.claude.json`,

❄️ 🔌 Snowflake MCP Managed VS Labs

# Snowflake MCP : `managed` vs `Snowflake-Labs/mcp`

Référence synthétique distinguant les **deux produits MCP** estampillés Snowflake. Confusion fréquente parce qu'ils partagent le nom et l'éditeur mais ciblent des usages opposés.

## En une phrase

- **Snowflake-managed MCP server** = produit Snowflake hébergé, créé comme objet SQL, exposé en HTTPS authentifié OAuth → cible **production entreprise**.
- **Snowflake-Labs/mcp** = implémentation open-source à lancer localement (`uvx`), configurée

test1

Select * from users where true

lm studio api key

sk-lm-HJPYSCyI:VZ3n8TyEq0i8ZrpJJrlf

DX Cleanup

// *** CONSTANTS *** //
const dxFolderName = "— DX —";
const boomTrackName = "BOOM";
const lavTrackName = "LAV";
const lavFaderLevel = "-8.0";

// *** FUNCTIONS *** //
function activateProTools() {
  sf.ui.proTools.appActivateMainWindow();
  sf.ui.proTools.appWaitForActive();
}

function changeTrackHeight() {
  if (sf.ui.useSfx) sf.ui.useSfx();
  if (!sf.ui.proTools.isRunning) throw "Pro Tools is not running";

  function setTrackHeight({ trackSize, scope = "selected" }) {
    const trackOptions

Pro Tools Session Prep

PT Session Prep Script — SoundFlow Compatible Workflow: 1. Reads VideoRef .mp4 filenames as the master name source 2. Loose-matches each to an AAF subfolder and renames it (the subfolder + the .aaf file inside) to match 3. Duplicates the PT template folder for each name into AUDIO/ProTools/<name>/<name>.ptx 4. Skips any session whose ProTools or VideoRef folder is green-tagged 5. Logs results to ~/Desktop/PrepScript_Log.txt

// ============================================================
// PT Session Prep Script — SoundFlow Compatible
//
// Workflow:
//   1. Reads VideoRef .mp4 filenames as the master name source
//   2. Loose-matches each to an AAF subfolder and renames it
//      (the subfolder + the .aaf file inside) to match
//   3. Duplicates the PT template folder for each name into
//      AUDIO/ProTools/<name>/<name>.ptx
//   4. Skips any session whose ProTools or VideoRef folder is green-tagged
//   5. Log

Delete Offline Video Clips

Goes through your Clip List and deletes all Offline Video clips after an AAF Import. This will eliminate the Missing Links popup from returning.

if (!sf.ui.proTools.isRunning) throw "Pro Tools is not running";

if (sf.ui.useSfx) sf.ui.useSfx();
sf.ui.proTools.appActivateMainWindow();

// Ensure Clips List is open
const clipListMenuItem = sf.ui.proTools.getMenuItem(
  "View",
  "Other Displays",
  "Clip List"
);

if (!clipListMenuItem.isMenuChecked) {
  sf.ui.proTools.menuClick({
    menuPath: ["View", "Other Displays", "Clip List"],
  });
  // Wait for window to open
  sf.wait();
}

// Access the Filter button (the button whose title mig

Bounce Mix


// ***** NOTES ***** //

/* The first thing the script does is check if any tracks are solo'd, then removes the solo.
/* Maybe add functionallity if you need multiple bounces. */
/* Try to remove the "" around the bonce presets. */
/* Try to add an option for NO PRESET. */
/* Add an option for Stems. If that button is clicked, it adds STEMS as a suffix to the file name instead of -MIX_ */
/* Add IF statement - if 0 tracks are selected, select the first track in the session. */





// ***** COD

Import AAF Files

/* CHECKLIST
- Make sure the Import Session Data window is visible.
- DESELECT the V1 track. Make sure the Audio tracks are all selected.
- Update any preferences and importing options. 
    - Use sf.app.proTools.importSessionData();
- Wait for the "Missing Files" dialogue box to appear.
- Select MAnually Find and Relink.
- Wait for the Relink window to appear.
- USE const CONFIG here.
    - Toggle Preset 1.
    - Find and check Client Folder.
- Click Find Links
- Click Options
- Wait for all Ta

Model Development

Simple Linear Regression: Predict --> y = b0 + b1x
  b0 = intercept    b1 = slope
Fit are arrays x=[], y=[] --> (b0,b1)

Import linear_model from scikit-learn
  from sklearn.linear_model import LinearRegression
  
Create a Linear Regression object using the constructor:
  lm=LinearRegression()
  
Define predictor and target variables
  x= df[['']]
  y=[['']]

Then "fit", find, the parameters of b0 and b1
  lm.fit(x,y)
  
Obtain prediction
  Yhat=lm.predict(x)

3120. Count the Number of Special Characters I

You are given a string word. A letter is called special if it appears both in lowercase and uppercase in word. Return the number of special letters in word.

/**
 * @param {string} word
 * @return {number}
 */
var numberOfSpecialChars = function(word) {
    // Track which lowercase and uppercase letters appear
    const lower = new Set();
    const upper = new Set();

    for (const ch of word) {
        if (ch >= 'a' && ch <= 'z') {
            lower.add(ch);
        } else {
            upper.add(ch);
        }
    }

    let count = 0;

    // Check all 26 letters
    for (let i = 0; i < 26; i++) {
        const lc = String.fromCharCode(97 + i); /

Product schema

{%- liquid
  assign rating_value = product.metafields.yotpo.reviews_average.value
  assign rating_count = product.metafields.yotpo.reviews_count.value
-%}

{%- capture product_category -%}
  {{- product.category.ancestors | join: ' > ' | append: ' > ' | append: product.category.name -}}
{%- endcapture -%}

{%- capture merchant_policy_json -%}
  {
    "@type": "MerchantReturnPolicy",
    "applicableCountry": "US",
    "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",

Stack, Merge, Repeat: Why Suika Game Turns Simple Fruit into Addictive Puzzle Fun

If you’ve ever found yourself hooked on a puzzle that feels both relaxing and oddly intense, you’ll probably enjoy the charm of Suika-style gameplay. At first glance, it’s just fruit dropping into a container. But give it a minute, and suddenly you’re calculating angles, planning merges, and holding your breath as everything teeters on the edge. That’s the magic behind [Suika Game](https://suikagame.lol) a deceptively simple puzzle that turns small decisions into surprisingly big consequences. Introduction: Simple Idea, Sneaky Depth The core idea is easy to grasp: you drop fruits into a box. When two identical fruits touch, they merge into a larger one. Your goal is to keep merging and creating bigger fruits without overflowing the container. Sounds straightforward, right? But as the space fills up and your fruit pile becomes unstable, every move starts to matter more. What makes this kind of puzzle so engaging is how it balances control and chaos. You choose where each fruit lands, but once it drops, physics takes over. Fruits roll, bounce, and shift in ways you can’t fully predict. That mix creates a loop that’s both calming and suspenseful at the same time. Gameplay: How It Actually Works Each round begins with an empty container and a stream of fruits waiting to be dropped. You move your current fruit left or right, then release it. When two identical fruits collide, they combine into a bigger fruit. That new fruit takes up more space, which makes future placements trickier. As you progress, the board fills unevenly. Gaps form. Tall stacks lean. Sometimes a perfect merge clears space, and other times a small mistake causes a chain reaction that pushes everything closer to the top. Once the fruit pile crosses the boundary line, the game ends. There’s no timer rushing you, which is part of the appeal. You can pause, think, and try to set up the next move. But even without a clock, tension builds naturally as the container fills up. You’ll often find yourself hesitating before dropping a piece, knowing it could either save your run or end it. Tips: Getting Better Without Overthinking It A good starting habit is to keep similar fruits close together. If you scatter them randomly, merges become harder and your space fills up faster. Try to “group” fruits so that future drops naturally connect. Another helpful approach is to build from one side. Instead of dropping fruits all over the place, focus on creating a structured pile. This reduces awkward gaps and gives you more control over how merges happen. Pay attention to how fruits roll after landing. A fruit doesn’t always stay where it first touches down. You can use that to your advantage by dropping pieces slightly off-target so they roll into the right spot. It’s also worth thinking one or two moves ahead. You don’t need a full strategy, but having a rough plan—like setting up a merge for your next fruit—can prevent messy situations. And maybe the most important tip: don’t panic when things get crowded. The game often looks worse than it actually is. A single well-placed drop can trigger multiple merges and open up space again. Conclusion: A Puzzle That Keeps Pulling You Back What makes Suika-style puzzles stand out isn’t complexity—it’s how much they do with so little. The rules are easy, the controls are simple, and yet every session feels slightly different. Some runs go smoothly, others fall apart quickly, and that unpredictability is part of the fun. It’s the kind of game you can play for a few minutes or lose an hour to without noticing. There’s always the feeling that you could do just a little better next time, make one smarter move, build one cleaner stack. If you enjoy puzzles that reward both patience and experimentation, this is an experience worth trying. Just don’t be surprised if “one more round” turns into many.

The Fruit That Fell from the Sky: Getting Hooked on Suika Game

Cacher is the code snippet organizer for pro developers

We empower you and your team to get more done, faster