Cacher is the code snippet organizer for pro developers

## Impeccable — the “design‑fluency” agent skill

**TL;DR** – Impeccable is a portable *agent skill* that gives any code‑generation LLM (Claude Code, Cursor, Gemini‑CLI, Codex CLI, etc.) a shared design vocabulary and a set of 23 concrete commands (`/impeccable …`).  
It can *teach* the model design fundamentals, *audit* a code‑base for UI anti‑patterns, *polish* existing UI, and even *live‑edit* components directly in the browser.  
You install it once (`npx skills add pbakaus/impeccable`) 

ios - xcrun simctl openurl booted "https://example.ru/"
android -  adb shell am start -a android.intent.action.VIEW -d "https://example.ru/"

re_MUhQG4gg_QCoTztF4heDf3rgA48ydrJYC

# Authentification à un proxy HTTP — Guide pédagogique

> Comprendre les différents schémas d'authentification HTTP utilisés par les proxies d'entreprise, du plus simple au plus sophistiqué, avec leurs forces, leurs limites et leur impact sur les outils en ligne de commande (curl, pip, dbt, etc.).

---

## 1. Pourquoi un proxy demande-t-il une authentification ?

Dans une infrastructure d'entreprise, **tout trafic Internet sortant** transite par un proxy. Ce dernier joue plusieurs rôles :

- **F

function convertFloatedImages() {

   const images = document.querySelectorAll(
      'p > img[style*="float"]'
   );

   images.forEach(img => {

      const parentP = img.parentElement;

      // create wrapper
      const wrapper = document.createElement('div');
      wrapper.className = 'float-wrapper';

      // get existing inline styles from image
      let wrapperStyles = img.getAttribute('style') || '';

      // apply width/height attributes as inline styles
      const width = img.get

/*
https://playwright.dev/docs/test-use-options#recording-options

With Playwright you can capture screenshots, record videos as well as traces of your test. By default these are turned off but you can enable them by setting the screenshot, video and trace options in your playwright.config.js file.

Trace files, screenshots and videos will appear in the test output directory, typically test-results.
*/

import { defineConfig } from '@playwright/test';

export default defineConfig({
  use: {
    

# 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