Cacher is the code snippet organizer for pro developers

# Module 1 — Objets PowerShell & pipeline objet

## Idée centrale

PowerShell **n'est pas un shell texte**. Le pipeline transporte des **objets .NET typés**, pas des chaînes de caractères. Ce qui s'affiche à l'écran est un *rendu* de l'objet en fin de pipeline, pas l'objet lui-même.

Conséquence directe : tu filtres, tries et transformes sur des **propriétés typées**, jamais en parsant du texte avec des regex.

```powershell
# bash : filtrage par parsing de texte (fragile, dépend du format de so

Absolutely, Weezy — here’s a detailed test intake you can paste directly into your agency workflow 🚀

Field	Description
Client Name	Marcus Johnson
Company Name	Urban Roots Wellness Co.
Project Description	Urban Roots Wellness Co. wants to build a modern, conversion-focused website and booking platform for their growing wellness brand. The company offers massage therapy, holistic wellness consultations, herbal products, breathwork sessions, and private wellness events. They currently rely on Inst

/**
 * @param {number[][]} tasks
 * @return {number}
 */
var minimumEffort = function(tasks) {
    // Sort by (minimum - actual) descending
    tasks.sort((a, b) => (b[1] - b[0]) - (a[1] - a[0]));

    let totalActual = 0; // sum of actual costs of tasks done so far
    let answer = 0;      // minimal initial energy required

    for (let [actual, minimum] of tasks) {
        // For this task, we need: initial >= minimum + totalActualBefore
        answer = Math.max(answer, minimum + totalActual

# `dbt snapshot`

> Commande de capture d'historique. Construit et maintient une table SCD2 reflétant l'évolution d'une source dans le temps. **Seule commande dbt qui produit un effet stateful** : chaque exécution accumule de la donnée.

---

## Ce que ça fait

`dbt snapshot` capture des **photos successives** d'une table source dans le temps. Chaque ligne de la table snapshot représente l'état d'une entité métier **pendant une période donnée**.

```
CUSTOMER (source aujourd'hui)
───────────────

# `dbt seed`

> Commande de chargement. Importe des fichiers CSV depuis `seeds/` et les matérialise comme **tables** sur le warehouse. Mécanisme de versionnement de petites données de référence avec le code.

---

## Ce que ça fait

`dbt seed` lit les fichiers CSV présents dans le dossier `seeds/` du projet et les matérialise comme tables sur le warehouse :

```
seeds/countries_region.csv      ──►   <database>.<schema>.countries_region (TABLE)
seeds/mpaa_rating_mapping.csv   ──►   <database>.<sc

# `dbt compile`

> Commande d'inspection et de validation. Parse le projet, résout le Jinja en SQL physique, écrit le résultat dans `target/compiled/`. Aucune matérialisation envoyée au warehouse.

---

## Ce que ça fait

`dbt compile` exécute toute la chaîne de préparation **sauf** la matérialisation :

- Lit `dbt_project.yml`, les `.sql` et les `.yml`
- Construit le DAG et met à jour `manifest.json`
- Évalue le Jinja, résout les `ref()` et `source()` en noms physiques
- Évalue les macros, y co

# `dbt test`

> Commande de validation. Exécute des requêtes de contrôle qualité sur les modèles déjà matérialisés.

---

## Ce que ça fait

`dbt test` exécute des **requêtes de validation** sur les tables et vues déjà matérialisées. Chaque test cherche des **violations** :

```
0 ligne retournée = test réussi (aucune violation)
≥1 ligne retournée = test échoué (N violations détectées)
```

C'est une logique **par la négative** : un test ne prouve pas que les données sont bonnes, il prouve qu'au

El truco es el siguiente, la regla general:


Se hace un ping a qinnova.uned.es:
ping qinnova.uned.es
Se mira la IP

Se hace un ping a la web que queremos comprobar. 
  - Si la ip no es la misma, entonces es cluster (PRO-3)
  - Si la ip sí es la misma, entonces es PRO  (pro)

# `dbt run`

> Commande de développement quotidien. Matérialise les modèles sélectionnés sur le warehouse, sans exécuter les tests.

---

## Ce que ça fait

`dbt run` compile le Jinja, génère le SQL, et envoie au warehouse les ordres de matérialisation pour les modèles sélectionnés.

| Matérialisation | SQL effectivement exécuté |
|-----------------|---------------------------|
| `view` | `CREATE OR REPLACE VIEW <schema>.<modele> AS <ton SELECT>` |
| `table` | `CREATE OR REPLACE TABLE <schema>.<

# `dbt build`

> Commande de production. Exécute le DAG complet (modèles, tests, snapshots, seeds) dans l'ordre topologique, avec garantie d'arrêt en aval d'un échec.

---

## Ce que ça fait

Pour chaque ressource du DAG, dans l'ordre topologique :

1. Matérialise la ressource (modèle, snapshot, seed)
2. Exécute immédiatement les tests qui lui sont attachés
3. Si un test échoue → les descendants sont **skippés** (pas matérialisés)

C'est l'équivalent fonctionnel de :

```bash
dbt run && dbt test

document.addEventListener("DOMContentLoaded", function () {
  // Get the accordion container
  const accordionContainer = document.querySelector(".footer-acc");

  // Only proceed if the container exists
  if (accordionContainer) {
    const firstItem = accordionContainer.querySelector(".x-acc-item");

    if (firstItem) {
      const button = firstItem.querySelector("button[role='button']");
      const panel = firstItem.querySelector("div[role='tabpanel']");

      if (button && panel) {
     

Describe data
  .describe()
  .value_counts()
    ex.  drive_wheel_counts=df["drive-wheels"].value_counts()
    
    drive_wheel_counts.rename(columns={'drive-wheels':'value_counts'} inplace=True)
    drive_wheel_counts.index.name = 'drive-wheels'

Box Plot
  sns.boxplot (x= "" , y= "" , data=df)
  
Scatter Plot
  y=df[""]
  x=df[""]
  plt.scatter(x,y)
  
  plt.title("")
  plt.xlabel("")
  plt.ylabel("")
  
GroupBy data
  .groupby()
    ex. df_test = df[['drive-wheels', 'body-style', 'price']]
 

#optinal

sudo apt-get update -y

sudo apt-get upgrade

#required

curl -fsSL https://get.docker.com -o get-docker.sh

sudo sh get-docker.sh

sudo usermod -aG docker ubuntu

newgrp docker

https://localsquash.com/

import { createTool } from '@mastra/core/tools';
import z from 'zod';
import { FilesystemEventType, FileType, Sandbox } from '@e2b/code-interpreter';

export const createSandbox = createTool({
  id: 'createSandbox',
  description: 'Create an e2b sandbox',
  inputSchema: z.object({
    metadata: z.record(z.string()).optional().describe('Custom metadata for the sandbox'),
    envs: z.record(z.string()).optional().describe(`
      Custom environment variables for the sandbox.
      Used 

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var separateDigits = function(nums) {
    const res = [];

    for (let n of nums) {
        // If the number is a single digit, just append it
        if (n < 10) {
            res.push(n);
            continue;
        }

        const stack = [];

        // Extract digits from right to left using modulo/division
        while (n > 0) {
            stack.push(n % 10);
            n = Math.floor(n / 10);
        }

        // Digits were