Init

.devdbrc

@@ -0,0 +1,6 @@
+[
+  {
+    "type": "sqlite",
+    "path": "/home/ninluc/Documents/school/IoT/smartWave/orchestrateur/db.sqlite"
+  }
+]

.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+    "python.analysis.extraPaths": [
+        "${workspaceFolder}",
+        "${workspaceFolder}/shared"
+    ],
+    "python.autoComplete.extraPaths": [
+        "${workspaceFolder}",
+        "${workspaceFolder}/shared"
+    ],
+    "python.defaultInterpreterPath": "${workspaceFolder}/venv/bin/python",
+    "r.lsp.promptToInstall": false,
+}

README.md

@@ -0,0 +1,2 @@
+
+`export PYTHONPATH=/home/pi/SmartWave`

deploy.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+
+# Configuration des ports (À remplacer par tes propres chemins by-id)
+# Pour trouver tes chemins, branche tes ESP et tape : ls -l /dev/serial/by-id/
+PORT_ESP_WIFI="/dev/serial/by-id/usb-Silicon_Labs_CP2102_USB_to_UART_Bridge_Controller_0001-if00-port0"
+PORT_ESP_LORA="/dev/serial/by-id/usb-Silicon_Labs_CP2102_USB_to_UART_Bridge_Controller_0002-if00-port0"
+# Ajoute les autres si besoin...
+
+# Configuration Raspberry Pi
+RPI_HOST="10.85.213.190"
+RPI_USER="pi"
+RPI_DEST="/home/pi/SmartWave"
+RPI_SYSTEMD_SERVICE="smartwave.service"
+
+# Vérification des arguments
+if [ -z "$1" ]; then
+    echo "Usage: ./deploy.sh [wifi|lora|rpi|all]"
+    exit 1
+fi
+
+CIBLE=$1
+
+# Fonction de déploiement
+deploy_to_esp() {
+    TARGET_DIR=$1
+    PORT=$2
+    NAME=$3
+
+    echo "======================================"
+    echo "🚀 Déploiement de [$NAME] sur $PORT"
+    echo "======================================"
+
+    if [ ! -e "$PORT" ]; then
+        echo "❌ Erreur : Le port $PORT est introuvable. L'ESP est-il branché ?"
+        return 1
+    fi
+
+    echo "📦 Copie du dossier shared/..."
+    # L'option 'cp -r' copie le contenu de façon récursive
+    mpremote connect "$PORT" cp -r shared/ :
+
+    echo "📂 Copie du code spécifique ($TARGET_DIR)..."
+    # Copie le contenu du dossier cible à la racine de l'ESP
+    mpremote connect "$PORT" cp -r "$TARGET_DIR"/* :
+
+    echo "📦 Copie des certificats MQTT..."
+    mpremote connect "$PORT" cp -r orchestrateur/mqtt/certs :certs
+
+    echo "🔄 Redémarrage de l'ESP..."
+    mpremote connect "$PORT" soft-reset
+
+    echo "✅ [$NAME] mis à jour avec succès !"
+    echo ""
+}
+
+deploy_to_rpi() {
+    echo "======================================"
+    echo "🚀 Déploiement vers le Raspberry Pi"
+    echo "======================================"
+
+    echo "📦 Synchronisation via rsync vers ${RPI_USER}:hepl@${RPI_HOST}:${RPI_DEST}..."
+    rsync -az --delete \
+        --exclude '.git' \
+        --exclude 'venv' \
+        --exclude '__pycache__' \
+        --exclude '*.pyc' \
+        --exclude '.mypy_cache' \
+        ./ "${RPI_USER}@${RPI_HOST}:${RPI_DEST}/"
+
+    echo "🔄 Redémarrage du service systemd ${RPI_SYSTEMD_SERVICE}..."
+    ssh "${RPI_USER}@${RPI_HOST}" "sudo systemctl restart ${RPI_SYSTEMD_SERVICE}"
+
+    echo "✅ Raspberry Pi mis à jour avec succès !"
+    echo ""
+}
+
+# Routage selon l'argument passé
+case $CIBLE in
+    "wifi")
+        deploy_to_esp "micro_ondes/esp_wifi" "$PORT_ESP_WIFI" "ESP-WIFI"
+        ;;
+    "lora")
+        deploy_to_esp "micro_ondes/esp_lora" "$PORT_ESP_LORA" "ESP-LORA"
+        ;;
+    "rpi")
+        deploy_to_rpi
+        ;;
+    "all")
+        deploy_to_esp "micro_ondes/esp_wifi" "$PORT_ESP_WIFI" "ESP-WIFI"
+        deploy_to_esp "micro_ondes/esp_lora" "$PORT_ESP_LORA" "ESP-LORA"
+        deploy_to_rpi
+        # Ajoute les autres ici
+        ;;
+    *)
+        echo "Cible inconnue. Utilise 'wifi', 'lora' ou 'all'."
+        ;;
+esac

orchestrateur/README.md

@@ -0,0 +1,5 @@
+
+# IP Adresses
+
+- AP (dynamic) : `10.85.213.190`
+- Generated Wifi : `192.168.50.1`

orchestrateur/compose.yaml

@@ -0,0 +1,19 @@
+services:
+  mqtt-broker:
+    image: eclipse-mosquitto:2.0
+    environment:
+      MQTT_TLS_ENABLED: ${MQTT_TLS_ENABLED:-true}
+    ports:
+      - "8884:8884"
+    volumes:
+      - ./mqtt/mosquitto-tls.conf:/mosquitto/config/mosquitto-tls.conf:ro
+      - ./mqtt/mosquitto-plain.conf:/mosquitto/config/mosquitto-plain.conf:ro
+      - ./mqtt/start-broker.sh:/scripts/start-broker.sh:ro
+      - ./mqtt/certs:/mosquitto/certs:ro
+      - mqtt-data:/mosquitto/data
+      - mqtt-log:/mosquitto/log
+    command: ["/bin/sh", "/scripts/start-broker.sh"]
+
+volumes:
+  mqtt-data:
+  mqtt-log:

orchestrateur/launch.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+set -eu
+
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+REPO_ROOT=$(dirname -- "$SCRIPT_DIR")
+PYTHON_BIN="${PYTHON_BIN:-python3}"
+PYTHON_SCRIPT="${1:-$SCRIPT_DIR/main.py}"
+REQUIREMENTS_FILE="$REPO_ROOT/requirements.txt"
+
+if [ ! -f "$PYTHON_SCRIPT" ]; then
+	echo "Python script not found: $PYTHON_SCRIPT" >&2
+	exit 1
+fi
+
+export PYTHONPATH="$REPO_ROOT${PYTHONPATH:+:$PYTHONPATH}"
+cd "$SCRIPT_DIR"
+docker compose pull
+docker compose up -d
+
+if [ -f "$REQUIREMENTS_FILE" ]; then
+	"$PYTHON_BIN" -m pip install --user -r "$REQUIREMENTS_FILE"
+fi
+
+cd "$REPO_ROOT"
+exec "$PYTHON_BIN" "$PYTHON_SCRIPT"

orchestrateur/mqtt/certs/ca.crt

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDWzCCAkOgAwIBAgIUfOrH/e2JrapgvuRGi0JZLhLfDm0wDQYJKoZIhvcNAQEL
+BQAwPTELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCXNtYXJ0V2F2ZTEaMBgGA1UEAwwR
+c21hcnRXYXZlIE1RVFQgQ0EwHhcNMjYwNzEzMTMyNzExWhcNMzYwNzEwMTMyNzEx
+WjA9MQswCQYDVQQGEwJGUjESMBAGA1UECgwJc21hcnRXYXZlMRowGAYDVQQDDBFz
+bWFydFdhdmUgTVFUVCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AKb5yNNrQJUZPJeDXGXgNLMXpUIgxdgA/USnrJAnItuORusJJoSTW7aa7JokHrb5
+CpN43b83E/tmU1juRMjTqaXK1CahlOz9ZSDxu8GsfW702BV9dU+3+3qMiCephf/x
+6VNmgwQ4FYW8/R1tQTSAySYbXck1UqEteRjMrYp4dedl3C24ZZvBGcTuER1Rv7Q5
+jypmsBceuEJYGqwijVGlbFY5B1wtKcdJhCpdBd2qijdtmJluCg0fO69ALFRK3ugy
+iXUqCcJyVVuIA4zLrp9tNmDxT6OJqsN9D/vyHNTUMpzozO8Sb8zFzZ69OfBCVxNJ
+r3/C7zSV0/UeBHgGAEo+3n0CAwEAAaNTMFEwHQYDVR0OBBYEFCRwYUUZB4FJx686
+1hqh0Oa0DcbqMB8GA1UdIwQYMBaAFCRwYUUZB4FJx6861hqh0Oa0DcbqMA8GA1Ud
+EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAGn649JZ8zx15RyVSGjcXGpx
+aaQNlL5l/xCMpxjsUT9/bpw1dEshGhiua/MgGm4VRUGUv5jMNZZQ72JhTNpsDFVU
+Ohh04VMYTE6N821BCKvK9odt2BWMfXPjN6vdMJb0tr1GKz6fNSUC+ufBTDRshfS+
+lOPzc9VlJudpA4oYFV9m3v2bSl+11Js0bIb9RIS2ThOJz9/B13YQ2HnZpX9t6o2T
+6QgxEEaxhHq4QcKZuwoZAqWEq28E+XiWkDnQw4M1GveaIQfbQHRGyKrret5TRL2U
+of/p//6DR9BpIPxTznrFTHn4a6lVtEeVS0n3UsUovWs88X2CWnrPN/Dk3DnNDqk=
+-----END CERTIFICATE-----

orchestrateur/mqtt/certs/ca.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCm+cjTa0CVGTyX
+g1xl4DSzF6VCIMXYAP1Ep6yQJyLbjkbrCSaEk1u2muyaJB62+QqTeN2/NxP7ZlNY
+7kTI06mlytQmoZTs/WUg8bvBrH1u9NgVfXVPt/t6jIgnqYX/8elTZoMEOBWFvP0d
+bUE0gMkmG13JNVKhLXkYzK2KeHXnZdwtuGWbwRnE7hEdUb+0OY8qZrAXHrhCWBqs
+Io1RpWxWOQdcLSnHSYQqXQXdqoo3bZiZbgoNHzuvQCxUSt7oMol1KgnCclVbiAOM
+y66fbTZg8U+jiarDfQ/78hzU1DKc6MzvEm/Mxc2evTnwQlcTSa9/wu80ldP1HgR4
+BgBKPt59AgMBAAECggEAApp6wPUh+iZ9FTMFTJ9XeFgM3xWUuslKfvi1o5UV9uIR
+MAFMr5zT6BUiou/0508bFPE5qo1oyy7YFixiN9a5BUPpf+VdZZPj25oj88vv3rwu
+5v2K8osV/t3/EiM+BXTCTxHA8YllqIKpraec8H0g5cO1Is8pMn3Q2WFORA5HGaxX
+PMbF3sd1CQGEUMR2yCc6RQriGOtp0e4kdkTZmmYKz8YqCM+D0HFxaLbvJq28QVwP
+ROvBIJIhNMhDXU6PbUXOrf7yzkQ6dfgZYJWphSLGtua4w2nto/kKUIJbVMD1eLMK
+3StsJJ0vGhT0EI/Z8A1N4YY2q0+XL+3tU+XaLHJQoQKBgQDrMVJ0ybjCiF85/n0m
+jyvxbdx/tpTaqqt4lnqp4mnC6oFGbKdo4UumIGNpV76hMUDb6LM9UTGjfiF8pj2z
+yFluqd/TnSAR9DHt/AdcRP94ruPdp3VcYXBf++dDMPmdKORiVbZBc6mlgDB4NnrD
+k1HklEF4CEJtB+bQR/4AILLvcQKBgQC1v3mcwSpAJ8A9TqdIHFLy5AsimwjdtxVh
+uHbGWjxRp+9AlkeXPMcUfWIoanmksGogXUwYWr3XQ5VRNmaB5DR6AMmn39Ubuon7
+gY7kC5q/p8FI3SHyS9UU030XE2RxtoeNlBGnTaECQ7Ks4tiHX5bFU3O4rj57tzKh
+QPr/NeixzQKBgAXcP8K7OAhY346RYcrxLFYit6jTAtiEAivKDBppktsRftEjafR6
+EKl+CxwX3J8lnAkevkCb4lHBldIGTmlJZ7kTMImUU7U+0XOtoP1Sls8KBJGEV69K
+mkM6AqQw9zdMSoyMuDLfT+3YyNxl9x8ib5rzesIj6ovO85hjAtg7+FlxAoGBALTf
+1+G/A5NRfCoHSsejGJINjV9lN0+f0zGraNlCGGGTZbG7XYgPvniPx849GM5jm1qW
+PxLFy8Sdx85I+38tY2Q/wHDHe8javlOEvnYJbnpqMxuWpyABhA/z4bvDWuUoKIMn
+5uG/igs84GbaY29mHCBJSxNypVBuI38DskemmOvJAoGAbBJwa6V3h43xubhqWlPb
+UDmlt7mzZ498zMlYleRPLs5iAHr2m2RGdoL684jyQmmgrwj0aTl8VPXqwu+Z58hf
+0liS/aoPcqjoxeNehtal819Sf7bPMaV7WXvX7P8JyP1mNIZbh5AbdPKPh1VeB53M
+eg7Z0O1YHzuZ0+62KMF6dcY=
+-----END PRIVATE KEY-----

orchestrateur/mqtt/certs/client-esp32-wifi.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDBDCCAewCFE4PS6lbdlWP0112ZDWDHopeXGXWMA0GCSqGSIb3DQEBCwUAMD0x
+CzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlzbWFydFdhdmUxGjAYBgNVBAMMEXNtYXJ0
+V2F2ZSBNUVRUIENBMB4XDTI2MDcxMzEzMjcxMloXDTM2MDcxMDEzMjcxMlowQDEL
+MAkGA1UEBhMCRlIxEjAQBgNVBAoMCXNtYXJ0V2F2ZTEdMBsGA1UEAwwUc21hcnR3
+YXZlLWVzcDMyLXdpZmkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCM
++9WP9tyVPmNpoYr66unjZS9dB0tOI1Lq5nCOPzNqOXEd1ev1OszMwyiEBMiKkiXA
+TYF7Lkm/0a0L37LreMqqNkFwErmB+ZvNUcCDdy/ktjCB3vg6Jm2hHndI8mDuRWiJ
+SQxfXtfZFvZ7R9HGPC+f1gtL1lvmbtG/pc+sFqDVxg+Gy/u9pivEAq/O509SfTpG
+6UDU6kOUkq3Nt6So4Mp7sQbhauDaMEH9sQ1fdIH1xYnSTdoUcWnoyVxs6iT6WKS9
+/c4oHVoOvrq5pL2o+4CU4M4p45tiBRwtoSqxH/WACix8LVzlh8w2d9gcR6bOncPY
+Zaq9FQv24Hw7yormIHcFAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAAOLPEECfPK8
+VR1I8PnPQlInyv/Kqz5sJVtDKmyhRcCzicskTZRDYQWeCidA7fCoy38QegzCpuMi
+nilMVdJKJcQI/hi8lN8mnzk7dQQcoAIKG1znNkc5swwkFIn0RbxLCNOVmqUiaLND
+WCsHOp56Zvu7FN/lmBxTZwCnqh3+VKhHsX3xGw20M6c2FEOo0/yiqL8yjZ+KWoI5
+bYRha7HxBexXQcWiIg8lV18sxS+cbokARr+d9l2MEz0bNQg8ugqiGIOrozZ5E0xK
+gZjFxY75W0XFuZLOVB4lhSd/D1F4eSCN+/sU20kDY1i5BvCDEXy34DZuIsZPrdbZ
+CBoQo6/jGJc=
+-----END CERTIFICATE-----

orchestrateur/mqtt/certs/client-esp32-wifi.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCM+9WP9tyVPmNp
+oYr66unjZS9dB0tOI1Lq5nCOPzNqOXEd1ev1OszMwyiEBMiKkiXATYF7Lkm/0a0L
+37LreMqqNkFwErmB+ZvNUcCDdy/ktjCB3vg6Jm2hHndI8mDuRWiJSQxfXtfZFvZ7
+R9HGPC+f1gtL1lvmbtG/pc+sFqDVxg+Gy/u9pivEAq/O509SfTpG6UDU6kOUkq3N
+t6So4Mp7sQbhauDaMEH9sQ1fdIH1xYnSTdoUcWnoyVxs6iT6WKS9/c4oHVoOvrq5
+pL2o+4CU4M4p45tiBRwtoSqxH/WACix8LVzlh8w2d9gcR6bOncPYZaq9FQv24Hw7
+yormIHcFAgMBAAECggEAEATbTrjPdnu4wvtSddE0UxyfpZPbGB1GYh9d4aPHvUWa
+lzfD0EDmnUt9coaynKAffvqvgCYRxiRWY7d+tmeqq21vwQK3pk+MxucHl0h3Hicf
+WtpRXRYZtclm51h28Avd5V9x8vItV2LXDcnqyXn0NVaWQP8xwPyNg5edAaIukyt7
+UtgHr4XXVEx9dgxDzK9UFOx3D8WqzlLg1Oc7nGFRjTytI/Sk0vCn1Rg6cTf42LBd
+R9FEbkeyAQ/7Bpk8ubIFAuN5htNq4mkZZiLRIJWZRy0LYrrY6X3/hZqILkch5VUJ
+hHUKblBvkqJeH1Vq4AMdivVqCg13pFlOHLtZqOt6jwKBgQC/AYS9oX0V8y4VBPkR
+YLTIb01xzVUl22wy0iuKJ3+kqp1TWdZIvNXAouU8FTZ4cxmKHRKeCe6rhAJQcbZB
+SK1uokqqVyMJ0+horWv60+B7EWE8ssvaIO8idfk7yPyX9kgMrIHbS6S7HDwDlsXC
+P5BPBjr2zngq5eEFQ37xF79CPwKBgQC89OSyCF/skudZZkJn7CP37Vn5aQVKamrE
+oQa7PQ30NN6+zR5W6a7pmVzyBS3BtIxEu91jw4yMjZXdf6vk1LEvpe+8K/rSZJuS
+9q0WzjRy//08qTnWHECWU1H+hW0v+HWngOyAtlb+xrrvo6fxVTYBA6OYXJKKreuy
+yY8W87otuwKBgQCR1x77i+pucBenhPyIAEcJI7MGSbnSBhA/XapQ+ofDu2IU2mt7
+bnPnenl9vtSwc3H0uu4ULZFG9Kyvr6NxhYSnDNPl7FKclmjGRGRGSLEGRubv6bUt
+ACiXL2z18Sis/ydURgOA5ekJ1S0dsGmfP9l3/VHYUR3/4zZFRpwOigtHEQKBgGoW
+aIwYLZsKQ3+q7R+hsfQRu5FPSFwmcTliWwAm4D26rVCcoysS2lRm+YscIzt9Hb+9
+ZigL8046c+i/NIgubiidVoLkglc7iykw+68xKLtkRA6ZyFIQ3KZJs2BeExZ6vbvE
+o4QEW8WBWBURYkoZmE9rdp8lYlUgHpPrnD27q0zfAoGBAI4AoiHWUmpZ3XbqvvCJ
+NP+Xq2vYahKT+atz/bmB1av9ZAgm3iqoy4so33ocXOlpYfnL5hi8Gkdqd1osjDx2
+vhQWg8u5ir8LOZbkAj+xHizKbsipXNUJS3CEDmsdtP2bv1Q5nUCz36+Na8yp7XMP
+88caMo7CMo8AbtbSJ3GFIK3S
+-----END PRIVATE KEY-----

orchestrateur/mqtt/certs/client-rpi.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIC/TCCAeUCFE4PS6lbdlWP0112ZDWDHopeXGXVMA0GCSqGSIb3DQEBCwUAMD0x
+CzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlzbWFydFdhdmUxGjAYBgNVBAMMEXNtYXJ0
+V2F2ZSBNUVRUIENBMB4XDTI2MDcxMzEzMjcxMloXDTM2MDcxMDEzMjcxMlowOTEL
+MAkGA1UEBhMCRlIxEjAQBgNVBAoMCXNtYXJ0V2F2ZTEWMBQGA1UEAwwNc21hcnR3
+YXZlLXJwaTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALwTCUvUOKIE
+Zo2vggxmc3awLoAxKyfxfvof3HWtp7jbj1TUKNVrfJ+nVjEwIrBtVrFpSrrbrnyS
+PYBN/JNvA7Zjw9UV0h3iEY2eL1i0ahTy+VvViQ3T6m1TDistC80e5iAnB7YmPUsK
+RFg4qDCtHylKuwl0ajml5+LwFg+SWTeLOnCnYbs8FSkaWmJHknpWyWKkOUdHxLQV
+EEpWif8VOm+EYblWroC6TkUQjQlhAvGAlYCpmeD+KXPwULZzO8JQBvo+IutJbeFT
+4HBZpMgxdWwkITHdSu+En0hzyrJciTKHiu+VwGN2yrktCuV3gJgIr1MYNFM8CE0D
+ELs0nxm2GiECAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAMyROjbMS5J03KZjtt2OS
+6OE+l8RKnKClHP4b1+LpHG9Jbacs3GfgH+CjeVT8ydGm9eaCgcm0O3YUfDdi/ebt
+/v+OQKFHfTVWea6njfy7+cv5d55ZtdCaPksvCgjoz0oXUHTuGtnUbtwzB32cS3rC
+4qGNVrqWB0ASKqDIxiBb6m/thhnoZ1d6s6QUA7gVM3xiADKFkWXq/liwvoCxBj9M
+KsKeo7GCBtxz/V9MZwH2vz+F2I/e3G7z3kyzmb6WhTuNr+xochI64Z8GcAoa1zx0
+q9/jycHrthk8LgVVBZJg7mdLxwS4h+WyRHy/+a0CX3x2JUrDLHP7jw7miEv7bn2o
+HQ==
+-----END CERTIFICATE-----

orchestrateur/mqtt/certs/client-rpi.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC8EwlL1DiiBGaN
+r4IMZnN2sC6AMSsn8X76H9x1rae4249U1CjVa3yfp1YxMCKwbVaxaUq62658kj2A
+TfyTbwO2Y8PVFdId4hGNni9YtGoU8vlb1YkN0+ptUw4rLQvNHuYgJwe2Jj1LCkRY
+OKgwrR8pSrsJdGo5pefi8BYPklk3izpwp2G7PBUpGlpiR5J6VslipDlHR8S0FRBK
+Von/FTpvhGG5Vq6Auk5FEI0JYQLxgJWAqZng/ilz8FC2czvCUAb6PiLrSW3hU+Bw
+WaTIMXVsJCEx3UrvhJ9Ic8qyXIkyh4rvlcBjdsq5LQrld4CYCK9TGDRTPAhNAxC7
+NJ8ZthohAgMBAAECggEAJ/Y+hy16dBiNxuTINATP22P/mW75HcVfRtvevuVtaibC
+65Ih9AkhA5ZthsmU0VqGLW+zOIWFq4PyS/EmLhiMWCSWH5CBoyZeNvJp2oYJNVbU
+W6pBcx34ZY7ch5mMdKLwYFwStCYnZ2qwz3MIb8FVSfOOTum8yW+CWFLNyTS+PsH5
+RxvxReiLa/O9xt0NMh8NTOfnF0dCeQaDon1GauvE28cMwGH07wDls8cPIZMlnx48
+zH46wfX8SGou9Rxyb5GLxRoMr/03xnSOnzE14eAzMl26KU8+1mi/VMA7QofmZGMp
+zED9+gckFAuVOSLyPdnb2nF+euAFOVxtvtMyqmSzXQKBgQD7URE9pmFEfbWxYEWO
+uIut1AFBu4cLomE1SSL8dPCFwiJh+yBBBq4VaoxfnxHBZW6baLOK0cxFqFXMiW8O
+HnS2nTb3YsFRlYahCStSNnUYCrpyRcqC0Ei2hJTOmbe+7A6i1fFPWMZ2RsUSEBJ+
+F9vbm8LRcPFUnCmRsjw/0yK/RQKBgQC/lEPObK/h+S+nwE/JW4KaZJM9WJyUiQAV
++ubnLiy08WeiFBRwckwl8UsxlNONTV2Myb3rR+U9ByLBxlgauQfY43RF4/cx3vjp
+nDGk4HtKBDjG73eG+KiTlDInNyTq/khL2RUBoWp+AA41M8GAUtkLGefz/YEoYBwC
+/74XQ66/LQKBgFg02dJDhTweyxiYa5FuIEhAcrh5cyqYMXocU1U8TfcEbkDpfSaV
+i6Akp2QgVoEEcs/E7c85V3LTZFnHmtzfv6MghtxJIwTZcEkxCK1wQ6TOjyXwbOWA
+6SR2YCwrM5ylCXYJlQp+ZBm7OQvf7D2pbhckEjqkY2+I5+YlIpRcLIPpAoGAAZuW
+7haPa1ASDFBa2w+/itgpPCyQM9bqf0S5x1rl2SblfcC5YzAyX2clAGeFVvw9Or8+
+rsjNrbNvoTyu5JqE7FcMVMHTA0IhyKQc7otLvZVHfLPpxuIzV/m4agfWcXps1OYf
+fQIDyMbrV5r1lsQbOjKfdba87L/RvFy1FbDluIkCgYEA9HKcXQS16wQmDGOrxfjk
+eSPshWj2x5lYgoB/BP68PNqDrfzChRLdV4xeDTD1DBM6iCIIWkRvL2kERwao9jT1
+lGNcNyvaudU4XC+5bpCFnrabqEdw+qJxI89PqD2gzIRivu8qEk5a7ffIR6BA5pGZ
+6cs8ObdBT1Py987DQZy5R14=
+-----END PRIVATE KEY-----

orchestrateur/mqtt/certs/server.crt

@@ -0,0 +1,23 @@
+-----BEGIN CERTIFICATE-----
+MIIDwTCCAqmgAwIBAgIUOMq5NlOQvK0Y8g4MhZTZXd9Og1AwDQYJKoZIhvcNAQEL
+BQAwPTELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCXNtYXJ0V2F2ZTEaMBgGA1UEAwwR
+c21hcnRXYXZlIE1RVFQgQ0EwHhcNMjYwNzEzMTM0MDIxWhcNMzYwNzEwMTM0MDIx
+WjA3MQswCQYDVQQGEwJGUjESMBAGA1UECgwJc21hcnRXYXZlMRQwEgYDVQQDDAtt
+cXR0LWJyb2tlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJCH+QVZ
+C5rkZVY3s22snt7jQkGUm+i8ac4wKtjxHJcerwmSsc9KZley54NP1mGDSmLS5Eu7
+1BeBut4d68E/6uAqeiMJDwD9C3J4zDM55SPlD73voPHr/M7NaKMNxW6HVzGUowot
+10BKO10MkMviXHzWwFpLjNrcCRI7NB5PDQFOppsbS7o78X9WjUzket07XuDI1mi+
+F3gqek2XAcc3EI1NN7X3Wv5x5pAV8ojsImcuSlBnqsj9D9O0POco42vJruomqC9e
+p68kfhwO1hvUW98bk6Qqve1bf4IT40lLslJJMXeWXd76WFbCdWzCvtqqIQmfVmh3
+yXzVRjAQcd5SsvsCAwEAAaOBvjCBuzBkBgNVHREEXTBbggttcXR0LWJyb2tlcoIJ
+bG9jYWxob3N0ggtyYXNwYmVycnlwaYIRcmFzcGJlcnJ5cGkubG9jYWyCD3NtYXJ0
+d2F2ZS5sb2NhbIcEfwAAAYcEwKgyAYcEClXVvjATBgNVHSUEDDAKBggrBgEFBQcD
+ATAdBgNVHQ4EFgQUvOWbGeFzR8Bh7MkTlEzt9jb51MgwHwYDVR0jBBgwFoAUJHBh
+RRkHgUnHrzrWGqHQ5rQNxuowDQYJKoZIhvcNAQELBQADggEBAF43q9IjR5NgUQbQ
+Bs34/bFKBUjNL6IzgMp5WeItDFx0eXK5gRmbY39dpb3cxP4L/ABJfEB8Ccl+wwp3
+NyAAKgTFQPFEdGppzi+6G65mXRZ58R+H90jDkRL9oWdq0cdaigPuaJUnRHhULZSR
+xkTpMky8zP5CgP/Zfs9k8LVuHWoepmh5mU2Wfz5/eDgdCEt8veDCuVpYQvR1zcoW
+53ECTJ63QkmhZ40LOLWaBOe//eS29CDCXjTOg25sY7z8C3YhU/IdpVxBDI9vvlV9
+aV5wxxQ9GxWy7yu1uDT1e+TjYPaPLsdMj0tvM/b8HGiRVszWntolMUJRfJ7mJmPC
+diLT1o4=
+-----END CERTIFICATE-----

orchestrateur/mqtt/certs/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCQh/kFWQua5GVW
+N7NtrJ7e40JBlJvovGnOMCrY8RyXHq8JkrHPSmZXsueDT9Zhg0pi0uRLu9QXgbre
+HevBP+rgKnojCQ8A/QtyeMwzOeUj5Q+976Dx6/zOzWijDcVuh1cxlKMKLddASjtd
+DJDL4lx81sBaS4za3AkSOzQeTw0BTqabG0u6O/F/Vo1M5HrdO17gyNZovhd4KnpN
+lwHHNxCNTTe191r+ceaQFfKI7CJnLkpQZ6rI/Q/TtDznKONrya7qJqgvXqevJH4c
+DtYb1FvfG5OkKr3tW3+CE+NJS7JSSTF3ll3e+lhWwnVswr7aqiEJn1Zod8l81UYw
+EHHeUrL7AgMBAAECggEAIjDAZJb5i1VPcbNwk1fcJ28Me/YbYdW8k+XKJRL4x/ke
+wD1/KcH4bvOoF+S5mszTuogYMKBI3py2Z5gdbtRfjFMQHJyme33hCN3xtIaUIccs
+z6pR4RkJ76QhBj2aQHjs1BJM9Xn9qzxESdFQqaKtbWziCRpJQnb+AF2YCTl7Ip0s
+4OK9bkzr4Q0a1XuceZvk1ooWeTFY30hVzb0pyY2DKV7+x0spYGbdZ/kCxPAK2pi1
+B0eYo0Uq6OK5BIs6SCqOhq5GNvU6ks0NdPlAQLJmAwEWEl5g4dOvQjb301jIvN80
+rLI65OG91iBw4vvsMK2rdyFwyyAeDZCfexATYAMc1QKBgQDLH7bUdAglJhzA+S3R
+qOeJf797BBNUkSUerk4SVj0tG/g0aOJ7VVNAUXI53M8JdvnTEEypnISiaoQVzdJ4
+Wo1osBRPqTdJ+1JssrRQcxpS2Ke3KXuArjn72+P8JnpweyDd1xSyudERAvEQQjyH
+iWyfi7CSKprLTZIO4wrNTNmT7wKBgQC2J5tIJ8n3oMQZg0UnyOqeDA6EVMKjH0Z3
+Ab2abpGRXIpWVDUnEUSIMd5aWJjYQ+OHOfPa5FS5f8h7MTXgCvz4ilNB/TFOVDH3
+wDax2N25LlyHKRCGstlFZiowXQFbPgGFkgKcxO7YjELRkj3nyKCR0VafYGq7fwwt
+723Hgc2VtQKBgBaY+aMbIYjYe5xwXEuV6eRfJPNPmcLvvtxx8deSZo3tLajO/ltQ
+O8nNBdMwIIxiAxsbFhxMgGj9RqKSWlbvZAoAhNHz9mWxoxLasrq8g3IyDj6PS+Ee
+AO9nIC7+LOL0n8xuUCwuBfdJh34SkF9Xx5DcXpF0UfJKN/SWB66dXRtbAoGBAJWo
+Yt9cuYZ3ksZ3YNk4LPNfaon07dmB964NQw9f6r+obYxSMT2A5XKUrmBCTIna9VSE
+G8NrN+UUhM4ad240+PTnCVK9SMZXTJqGVSm3ySu9WI5AAfD5fqOTNfR4ZYXmou9w
+MC9HagmG69stsSj/YFWNzgKx/98+me4fum1hS1zFAoGAD/b9UQKB6hr4dIxwtdff
+IDvmYz0BINTjSfk++rGu22Y4wj11ueVyadJblzBTGcgXlcHO3iJ5DPhLTjutBi0w
+8SXCy6kpohqImo23qKqprVpTaaQAYsSqn/9gTd8sVqD7tGr86wng+Aa8tLlMDOpw
+3ZjOstJIJO0Wrr3gNcoeFAc=
+-----END PRIVATE KEY-----

orchestrateur/mqtt/mosquitto-plain.conf

@@ -0,0 +1,12 @@
+persistence true
+persistence_location /mosquitto/data/
+autosave_interval 60
+log_dest stdout
+log_type error
+log_type warning
+log_type notice
+log_type information
+allow_anonymous true
+
+listener 8884
+protocol mqtt

orchestrateur/mqtt/mosquitto-tls.conf

@@ -0,0 +1,17 @@
+persistence true
+persistence_location /mosquitto/data/
+autosave_interval 60
+log_dest stdout
+log_type error
+log_type warning
+log_type notice
+log_type information
+allow_anonymous true
+
+listener 8884
+protocol mqtt
+cafile /mosquitto/certs/ca.crt
+certfile /mosquitto/certs/server.crt
+keyfile /mosquitto/certs/server.key
+require_certificate false
+tls_version tlsv1.2

orchestrateur/mqtt/start-broker.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+set -eu
+
+CONFIG_DIR="${CONFIG_DIR:-/mosquitto/config}"
+RUNTIME_CONF="${RUNTIME_CONF:-/tmp/mosquitto.conf}"
+MQTT_TLS_ENABLED="${MQTT_TLS_ENABLED:-true}"
+
+case "$MQTT_TLS_ENABLED" in
+    true|1|yes|on)
+        cp "$CONFIG_DIR/mosquitto-tls.conf" "$RUNTIME_CONF"
+        ;;
+    *)
+        cp "$CONFIG_DIR/mosquitto-plain.conf" "$RUNTIME_CONF"
+        ;;
+esac
+
+exec mosquitto -c "$RUNTIME_CONF"

other/smartwave.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=SmartWave application service
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=pi
+Group=pi
+WorkingDirectory=/home/pi/SmartWave
+EnvironmentFile=-/etc/default/smartwave
+ExecStart=/bin/sh -lc '${SMARTWAVE_EXEC_START:?Set SMARTWAVE_EXEC_START in /etc/default/smartwave}'
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target

requirements.txt

@@ -0,0 +1 @@
+paho-mqtt>=1.6,<3

shared/__init__.py

@@ -0,0 +1,6 @@
+"""Shared helpers for the smartWave project."""
+
+from .db import DRIVER_NAME, Database, connect, execute, fetchall, fetchone
+from .mqtt import BACKEND_NAME as MQTT_BACKEND_NAME, BrokerClient, connect as mqtt_connect, publish as mqtt_publish
+
+

shared/db.py

@@ -0,0 +1,102 @@
+"""Small sqlite compatibility layer for CPython and MicroPython.
+
+The module exposes a tiny wrapper around the available sqlite driver so the
+same code can run on CPython (`sqlite3`) and MicroPython (`sqlite3` or
+`usqlite`, depending on the port).
+"""
+
+try:
+	import sqlite3 as _sqlite
+	DRIVER_NAME = "sqlite3"
+except ImportError:
+	try:
+		import usqlite as _sqlite
+		DRIVER_NAME = "usqlite"
+	except ImportError as exc:
+		raise ImportError("No sqlite driver found. Expected sqlite3 or usqlite.") from exc
+
+
+def _connect(database_path, **connect_kwargs):
+	if connect_kwargs:
+		try:
+			return _sqlite.connect(database_path, **connect_kwargs)
+		except TypeError:
+			pass
+	return _sqlite.connect(database_path)
+
+
+class Database:
+	"""Lightweight connection wrapper with a consistent API."""
+
+	def __init__(self, database_path, **connect_kwargs):
+		self._database_path = database_path
+		self._connect_kwargs = connect_kwargs
+		self._connection = None
+
+	def open(self):
+		if self._connection is None:
+			self._connection = _connect(self._database_path, **self._connect_kwargs)
+		return self._connection
+
+	def close(self):
+		if self._connection is not None:
+			self._connection.close()
+			self._connection = None
+
+	def commit(self):
+		connection = self.open()
+		if hasattr(connection, "commit"):
+			connection.commit()
+
+	def cursor(self):
+		return self.open().cursor()
+
+	def execute(self, sql, params=None):
+		cursor = self.cursor()
+		if params is None:
+			cursor.execute(sql)
+		else:
+			cursor.execute(sql, params)
+		return cursor
+
+	def executemany(self, sql, params_list):
+		cursor = self.cursor()
+		cursor.executemany(sql, params_list)
+		return cursor
+
+	def fetchone(self, sql, params=None):
+		return self.execute(sql, params).fetchone()
+
+	def fetchall(self, sql, params=None):
+		return self.execute(sql, params).fetchall()
+
+	def executescript(self, script):
+		connection = self.open()
+		if hasattr(connection, "executescript"):
+			return connection.executescript(script)
+		raise NotImplementedError("executescript is not available on this sqlite backend")
+
+	def __enter__(self):
+		self.open()
+		return self
+
+	def __exit__(self, exc_type, exc, traceback):
+		if exc_type is None:
+			self.commit()
+		self.close()
+
+
+def connect(database_path, **connect_kwargs):
+	return Database(database_path, **connect_kwargs)
+
+
+def execute(database_path, sql, params=None, **connect_kwargs):
+	return connect(database_path, **connect_kwargs).execute(sql, params)
+
+
+def fetchone(database_path, sql, params=None, **connect_kwargs):
+	return connect(database_path, **connect_kwargs).fetchone(sql, params)
+
+
+def fetchall(database_path, sql, params=None, **connect_kwargs):
+	return connect(database_path, **connect_kwargs).fetchall(sql, params)

shared/mqtt.py

@@ -0,0 +1,218 @@
+"""Small MQTT compatibility layer for CPython and MicroPython.
+
+The wrapper keeps the broker host explicit so embedded clients can point to a
+real IP address instead of localhost.
+"""
+
+try:
+    import paho.mqtt.client as _mqtt
+    BACKEND_NAME = "paho"
+    IS_MICROPYTHON = False
+except ImportError:
+    try:
+        from umqtt.simple import MQTTClient as _MQTTClient
+        BACKEND_NAME = "umqtt.simple"
+        IS_MICROPYTHON = True
+    except ImportError:
+        try:
+            from umqtt.robust import MQTTClient as _MQTTClient
+            BACKEND_NAME = "umqtt.robust"
+            IS_MICROPYTHON = True
+        except ImportError as exc:
+            raise ImportError("No MQTT client found. Expected paho.mqtt or umqtt.") from exc
+
+
+DEFAULT_PORT = 8884
+DEFAULT_CA_FILE = "orchestrateur/mqtt/certs/ca.crt"
+
+
+def _resolve_host(host):
+    if host:
+        return host
+
+    try:
+        import os
+
+        getenv = getattr(os, "getenv", None)
+        if getenv is not None:
+            host = getenv("MQTT_BROKER_HOST")
+    except Exception:
+        host = None
+
+    if not host:
+        raise ValueError("MQTT broker host is required. Pass the broker IP address instead of localhost.")
+
+    return host
+
+
+def _ensure_bytes(payload):
+    if payload is None:
+        return b""
+    if isinstance(payload, bytes):
+        return payload
+    if isinstance(payload, bytearray):
+        return bytes(payload)
+    return str(payload).encode()
+
+
+def _read_file_bytes(path):
+    with open(path, "rb") as handle:
+        return handle.read()
+
+
+class BrokerClient:
+    """Small MQTT client with a normalised API across runtimes."""
+
+    def __init__(self, host=None, port=DEFAULT_PORT, client_id=None, use_tls=True, cafile=None, certfile=None, keyfile=None, ssl_params=None, tls_insecure=False, username=None, password=None, keepalive=60):
+        self.host = _resolve_host(host)
+        self.port = port
+        self.client_id = client_id
+        self.use_tls = use_tls
+        self.cafile = cafile or DEFAULT_CA_FILE
+        self.certfile = certfile
+        self.keyfile = keyfile
+        self.ssl_params = ssl_params
+        self.tls_insecure = tls_insecure
+        self.username = username
+        self.password = password
+        self.keepalive = keepalive
+        self._client = None
+        self._callback = None
+        self._messages = []
+
+    def set_callback(self, callback):
+        self._callback = callback
+        if self._client is not None and not IS_MICROPYTHON:
+            self._client.on_message = self._on_message
+
+    def _store_message(self, topic, payload, qos=None, retain=False):
+        message = {
+            "topic": topic,
+            "payload": payload,
+            "qos": qos,
+            "retain": retain,
+        }
+        self._messages.append(message)
+        if self._callback is not None:
+            self._callback(message)
+
+    def _on_message(self, client, userdata, msg):
+        self._store_message(msg.topic, msg.payload, getattr(msg, "qos", None), getattr(msg, "retain", False))
+
+    def open(self):
+        if self._client is not None:
+            return self._client
+
+        if IS_MICROPYTHON:
+            ssl_params = self.ssl_params
+            if self.use_tls and ssl_params is None and self.cafile is not None:
+                ssl_params = {"cadata": _read_file_bytes(self.cafile)}
+            client = _MQTTClient(
+                self.client_id or "smartWave-client",
+                self.host,
+                port=self.port,
+                user=self.username,
+                password=self.password,
+                keepalive=self.keepalive,
+                ssl=self.use_tls or ssl_params is not None,
+                ssl_params=ssl_params,
+            )
+            self._client = client
+            return self._client
+
+        client = _mqtt.Client(client_id=self.client_id or "", clean_session=True, protocol=4, transport="tcp")
+        if self.username is not None or self.password is not None:
+            client.username_pw_set(self.username, self.password)
+        if self.use_tls:
+            tls_kwargs = {}
+            if self.cafile is not None:
+                tls_kwargs["ca_certs"] = self.cafile
+            if self.certfile is not None:
+                tls_kwargs["certfile"] = self.certfile
+            if self.keyfile is not None:
+                tls_kwargs["keyfile"] = self.keyfile
+            if tls_kwargs:
+                client.tls_set(**tls_kwargs)
+            else:
+                client.tls_set()
+            if self.tls_insecure:
+                client.tls_insecure_set(True)
+        client.on_message = self._on_message
+        self._client = client
+        return self._client
+
+    def connect(self):
+        client = self.open()
+        if IS_MICROPYTHON:
+            client.connect()
+            return client
+
+        client.connect(self.host, self.port, self.keepalive)
+        return client
+
+    def publish(self, topic, payload, qos=2, retain=False):
+        client = self.open()
+        payload_bytes = _ensure_bytes(payload)
+        if IS_MICROPYTHON:
+            return client.publish(topic, payload_bytes, retain=retain, qos=qos)
+        return client.publish(topic, payload_bytes, qos=qos, retain=retain)
+
+    def subscribe(self, topic, qos=2):
+        client = self.open()
+        if IS_MICROPYTHON:
+            client.set_callback(self._on_micropython_message)
+            return client.subscribe(topic, qos=qos)
+        return client.subscribe(topic, qos=qos)
+
+    def _on_micropython_message(self, topic, payload):
+        self._store_message(topic, payload, None, False)
+
+    def poll(self, timeout=0.1):
+        if self._client is None:
+            return None
+        if IS_MICROPYTHON:
+            return self._client.check_msg()
+        return self._client.loop(timeout=timeout)
+
+    def wait(self):
+        if self._client is None:
+            return None
+        if IS_MICROPYTHON:
+            return self._client.wait_msg()
+        return self._client.loop_forever()
+
+    def get_message(self):
+        if not self._messages:
+            return None
+        return self._messages.pop(0)
+
+    def close(self):
+        if self._client is None:
+            return
+        try:
+            self._client.disconnect()
+        except Exception:
+            pass
+        self._client = None
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc, traceback):
+        self.close()
+
+
+def connect(host=None, **client_kwargs):
+    return BrokerClient(host=host, **client_kwargs)
+
+
+def publish(host, topic, payload, **client_kwargs):
+    qos = client_kwargs.pop("qos", 2)
+    retain = client_kwargs.pop("retain", False)
+    client = connect(host=host, **client_kwargs)
+    client.connect()
+    try:
+        return client.publish(topic, payload, qos=qos, retain=retain)
+    finally:
+        client.close()

smartwave.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=SmartWave application service
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=pi
+Group=pi
+WorkingDirectory=/home/pi/SmartWave
+EnvironmentFile=-/etc/default/smartwave
+ExecStart=/bin/sh /home/pi/SmartWave/orchestrateur/launch.sh /home/pi/SmartWave/orchestrateur/main.py
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target

tests/mqtt/README.md

@@ -0,0 +1,13 @@
+# MQTT Examples
+
+Small examples for the shared MQTT wrapper.
+
+The examples use an explicit broker IP address. Replace `192.168.1.50` with the
+real address of the machine running the broker.
+
+TLS is enabled by default in the broker stack. For Wireshark testing, start the
+broker with `MQTT_TLS_ENABLED=false` and use the plain example path.
+
+
+# On asus
+

tests/mqtt/cpython_example.py

@@ -0,0 +1,48 @@
+"""Small CPython MQTT example.
+
+Publish a QoS 2 message and then subscribe to the same topic.
+Set MQTT_BROKER_HOST to the broker IP address, not localhost.
+"""
+
+import os
+import time
+from pathlib import Path
+
+from shared.mqtt import BrokerClient
+
+
+BROKER_HOST = os.getenv("MQTT_BROKER_HOST", "localhost")
+TOPIC = "smartwave/demo"
+USE_TLS = os.getenv("MQTT_CLIENT_TLS", "true").lower() in {"1", "true", "yes", "on"}
+CA_FILE = os.getenv(
+    "MQTT_CA_FILE",
+    str(Path(__file__).resolve().parents[2] / "orchestrateur" / "mqtt" / "certs" / "ca.crt"),
+)
+
+
+def main():
+    client = BrokerClient(
+        host=BROKER_HOST,
+        client_id="smartwave-cpython-demo",
+        use_tls=USE_TLS,
+        cafile=CA_FILE,
+        keepalive=30,
+    )
+
+    client.connect()
+    client.subscribe(TOPIC, qos=2)
+    client.publish(TOPIC, "hello from CPython", qos=2, retain=False)
+
+    deadline = time.time() + 3
+    while time.time() < deadline:
+        client.poll(0.1)
+        message = client.get_message()
+        if message is not None:
+            print("received:", message)
+            break
+
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

tests/mqtt/micropython_example.py

@@ -0,0 +1,39 @@
+"""Small MicroPython MQTT example for ESP32.
+
+Edit BROKER_HOST so it points to the broker machine IP address.
+Do not use localhost from the ESP32.
+"""
+
+from shared.mqtt import BrokerClient
+
+
+BROKER_HOST = "192.168.50.1"
+TOPIC = b"smartwave/demo"
+CA_FILE = "/certs/ca.crt"
+
+
+def on_message(message):
+    print("received:", message)
+
+
+def main():
+    client = BrokerClient(
+        host=BROKER_HOST,
+        client_id="smartwave-esp32-demo",
+        use_tls=True,
+        cafile=CA_FILE,
+        keepalive=30,
+    )
+
+    client.set_callback(on_message)
+    client.connect()
+    client.subscribe(TOPIC, qos=2)
+    client.publish(TOPIC, b"hello from MicroPython", qos=2, retain=False)
+
+    for _ in range(30):
+        client.poll()
+
+    client.close()
+
+
+main()

venv/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

venv/bin/activate

@@ -0,0 +1,70 @@
+# This file must be used with "source bin/activate" *from bash*
+# You cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past commands. Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+# on Windows, a path can contain colons and backslashes and has to be converted:
+if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then
+    # transform D:\path\to\venv to /d/path/to/venv on MSYS
+    # and to /cygdrive/d/path/to/venv on Cygwin
+    export VIRTUAL_ENV=$(cygpath /home/ninluc/Documents/school/IoT/smartWave/venv)
+else
+    # use the path as-is
+    export VIRTUAL_ENV=/home/ninluc/Documents/school/IoT/smartWave/venv
+fi
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"bin":$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1='(venv) '"${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT='(venv) '
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

venv/bin/activate.csh

@@ -0,0 +1,27 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV /home/ninluc/Documents/school/IoT/smartWave/venv
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = '(venv) '"$prompt"
+    setenv VIRTUAL_ENV_PROMPT '(venv) '
+endif
+
+alias pydoc python -m pydoc
+
+rehash

venv/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/). You cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV /home/ninluc/Documents/school/IoT/smartWave/venv
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) '(venv) ' (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT '(venv) '
+end

venv/bin/flask

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from flask.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/idna

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from idna.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/mpremote

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from mpremote.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/normalizer

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from charset_normalizer.cli import cli_detect
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli_detect())

venv/bin/pip

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3.12

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pyserial-miniterm

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from serial.tools.miniterm import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pyserial-ports

@@ -0,0 +1,8 @@
+#!/home/ninluc/Documents/school/IoT/smartWave/venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from serial.tools.list_ports import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/python

@@ -0,0 +1 @@
+python3

venv/bin/python3

@@ -0,0 +1 @@
+/usr/bin/python3

venv/bin/python3.12

@@ -0,0 +1 @@
+python3

venv/lib/python3.12/site-packages/blinker-1.9.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/lib/python3.12/site-packages/blinker-1.9.0.dist-info/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright 2010 Jason Kirtland
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

venv/lib/python3.12/site-packages/blinker-1.9.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.3
+Name: blinker
+Version: 1.9.0
+Summary: Fast, simple object-to-object and broadcast signaling
+Author: Jason Kirtland
+Maintainer-email: Pallets Ecosystem <contact@palletsprojects.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Typing :: Typed
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://blinker.readthedocs.io
+Project-URL: Source, https://github.com/pallets-eco/blinker/
+
+# Blinker
+
+Blinker provides a fast dispatching system that allows any number of
+interested parties to subscribe to events, or "signals".
+
+
+## Pallets Community Ecosystem
+
+> [!IMPORTANT]\
+> This project is part of the Pallets Community Ecosystem. Pallets is the open
+> source organization that maintains Flask; Pallets-Eco enables community
+> maintenance of related projects. If you are interested in helping maintain
+> this project, please reach out on [the Pallets Discord server][discord].
+>
+> [discord]: https://discord.gg/pallets
+
+
+## Example
+
+Signal receivers can subscribe to specific senders or receive signals
+sent by any sender.
+
+```pycon
+>>> from blinker import signal
+>>> started = signal('round-started')
+>>> def each(round):
+...     print(f"Round {round}")
+...
+>>> started.connect(each)
+
+>>> def round_two(round):
+...     print("This is round two.")
+...
+>>> started.connect(round_two, sender=2)
+
+>>> for round in range(1, 4):
+...     started.send(round)
+...
+Round 1!
+Round 2!
+This is round two.
+Round 3!
+```
+

venv/lib/python3.12/site-packages/blinker-1.9.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+blinker-1.9.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+blinker-1.9.0.dist-info/LICENSE.txt,sha256=nrc6HzhZekqhcCXSrhvjg5Ykx5XphdTw6Xac4p-spGc,1054
+blinker-1.9.0.dist-info/METADATA,sha256=uIRiM8wjjbHkCtbCyTvctU37IAZk0kEe5kxAld1dvzA,1633
+blinker-1.9.0.dist-info/RECORD,,
+blinker-1.9.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+blinker/__init__.py,sha256=I2EdZqpy4LyjX17Hn1yzJGWCjeLaVaPzsMgHkLfj_cQ,317
+blinker/__pycache__/__init__.cpython-312.pyc,,
+blinker/__pycache__/_utilities.cpython-312.pyc,,
+blinker/__pycache__/base.cpython-312.pyc,,
+blinker/_utilities.py,sha256=0J7eeXXTUx0Ivf8asfpx0ycVkp0Eqfqnj117x2mYX9E,1675
+blinker/base.py,sha256=QpDuvXXcwJF49lUBcH5BiST46Rz9wSG7VW_p7N_027M,19132
+blinker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

venv/lib/python3.12/site-packages/blinker-1.9.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py3-none-any

venv/lib/python3.12/site-packages/blinker/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from .base import ANY
+from .base import default_namespace
+from .base import NamedSignal
+from .base import Namespace
+from .base import Signal
+from .base import signal
+
+__all__ = [
+    "ANY",
+    "default_namespace",
+    "NamedSignal",
+    "Namespace",
+    "Signal",
+    "signal",
+]

venv/lib/python3.12/site-packages/blinker/_utilities.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import collections.abc as c
+import inspect
+import typing as t
+from weakref import ref
+from weakref import WeakMethod
+
+T = t.TypeVar("T")
+
+
+class Symbol:
+    """A constant symbol, nicer than ``object()``. Repeated calls return the
+    same instance.
+
+    >>> Symbol('foo') is Symbol('foo')
+    True
+    >>> Symbol('foo')
+    foo
+    """
+
+    symbols: t.ClassVar[dict[str, Symbol]] = {}
+
+    def __new__(cls, name: str) -> Symbol:
+        if name in cls.symbols:
+            return cls.symbols[name]
+
+        obj = super().__new__(cls)
+        cls.symbols[name] = obj
+        return obj
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __repr__(self) -> str:
+        return self.name
+
+    def __getnewargs__(self) -> tuple[t.Any, ...]:
+        return (self.name,)
+
+
+def make_id(obj: object) -> c.Hashable:
+    """Get a stable identifier for a receiver or sender, to be used as a dict
+    key or in a set.
+    """
+    if inspect.ismethod(obj):
+        # The id of a bound method is not stable, but the id of the unbound
+        # function and instance are.
+        return id(obj.__func__), id(obj.__self__)
+
+    if isinstance(obj, (str, int)):
+        # Instances with the same value always compare equal and have the same
+        # hash, even if the id may change.
+        return obj
+
+    # Assume other types are not hashable but will always be the same instance.
+    return id(obj)
+
+
+def make_ref(obj: T, callback: c.Callable[[ref[T]], None] | None = None) -> ref[T]:
+    if inspect.ismethod(obj):
+        return WeakMethod(obj, callback)  # type: ignore[arg-type, return-value]
+
+    return ref(obj, callback)

venv/lib/python3.12/site-packages/blinker/base.py

@@ -0,0 +1,512 @@
+from __future__ import annotations
+
+import collections.abc as c
+import sys
+import typing as t
+import weakref
+from collections import defaultdict
+from contextlib import contextmanager
+from functools import cached_property
+from inspect import iscoroutinefunction
+
+from ._utilities import make_id
+from ._utilities import make_ref
+from ._utilities import Symbol
+
+F = t.TypeVar("F", bound=c.Callable[..., t.Any])
+
+ANY = Symbol("ANY")
+"""Symbol for "any sender"."""
+
+ANY_ID = 0
+
+
+class Signal:
+    """A notification emitter.
+
+    :param doc: The docstring for the signal.
+    """
+
+    ANY = ANY
+    """An alias for the :data:`~blinker.ANY` sender symbol."""
+
+    set_class: type[set[t.Any]] = set
+    """The set class to use for tracking connected receivers and senders.
+    Python's ``set`` is unordered. If receivers must be dispatched in the order
+    they were connected, an ordered set implementation can be used.
+
+    .. versionadded:: 1.7
+    """
+
+    @cached_property
+    def receiver_connected(self) -> Signal:
+        """Emitted at the end of each :meth:`connect` call.
+
+        The signal sender is the signal instance, and the :meth:`connect`
+        arguments are passed through: ``receiver``, ``sender``, and ``weak``.
+
+        .. versionadded:: 1.2
+        """
+        return Signal(doc="Emitted after a receiver connects.")
+
+    @cached_property
+    def receiver_disconnected(self) -> Signal:
+        """Emitted at the end of each :meth:`disconnect` call.
+
+        The sender is the signal instance, and the :meth:`disconnect` arguments
+        are passed through: ``receiver`` and ``sender``.
+
+        This signal is emitted **only** when :meth:`disconnect` is called
+        explicitly. This signal cannot be emitted by an automatic disconnect
+        when a weakly referenced receiver or sender goes out of scope, as the
+        instance is no longer be available to be used as the sender for this
+        signal.
+
+        An alternative approach is available by subscribing to
+        :attr:`receiver_connected` and setting up a custom weakref cleanup
+        callback on weak receivers and senders.
+
+        .. versionadded:: 1.2
+        """
+        return Signal(doc="Emitted after a receiver disconnects.")
+
+    def __init__(self, doc: str | None = None) -> None:
+        if doc:
+            self.__doc__ = doc
+
+        self.receivers: dict[
+            t.Any, weakref.ref[c.Callable[..., t.Any]] | c.Callable[..., t.Any]
+        ] = {}
+        """The map of connected receivers. Useful to quickly check if any
+        receivers are connected to the signal: ``if s.receivers:``. The
+        structure and data is not part of the public API, but checking its
+        boolean value is.
+        """
+
+        self.is_muted: bool = False
+        self._by_receiver: dict[t.Any, set[t.Any]] = defaultdict(self.set_class)
+        self._by_sender: dict[t.Any, set[t.Any]] = defaultdict(self.set_class)
+        self._weak_senders: dict[t.Any, weakref.ref[t.Any]] = {}
+
+    def connect(self, receiver: F, sender: t.Any = ANY, weak: bool = True) -> F:
+        """Connect ``receiver`` to be called when the signal is sent by
+        ``sender``.
+
+        :param receiver: The callable to call when :meth:`send` is called with
+            the given ``sender``, passing ``sender`` as a positional argument
+            along with any extra keyword arguments.
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender. A receiver may be connected
+            to multiple senders by calling :meth:`connect` multiple times.
+        :param weak: Track the receiver with a :mod:`weakref`. The receiver will
+            be automatically disconnected when it is garbage collected. When
+            connecting a receiver defined within a function, set to ``False``,
+            otherwise it will be disconnected when the function scope ends.
+        """
+        receiver_id = make_id(receiver)
+        sender_id = ANY_ID if sender is ANY else make_id(sender)
+
+        if weak:
+            self.receivers[receiver_id] = make_ref(
+                receiver, self._make_cleanup_receiver(receiver_id)
+            )
+        else:
+            self.receivers[receiver_id] = receiver
+
+        self._by_sender[sender_id].add(receiver_id)
+        self._by_receiver[receiver_id].add(sender_id)
+
+        if sender is not ANY and sender_id not in self._weak_senders:
+            # store a cleanup for weakref-able senders
+            try:
+                self._weak_senders[sender_id] = make_ref(
+                    sender, self._make_cleanup_sender(sender_id)
+                )
+            except TypeError:
+                pass
+
+        if "receiver_connected" in self.__dict__ and self.receiver_connected.receivers:
+            try:
+                self.receiver_connected.send(
+                    self, receiver=receiver, sender=sender, weak=weak
+                )
+            except TypeError:
+                # TODO no explanation or test for this
+                self.disconnect(receiver, sender)
+                raise
+
+        return receiver
+
+    def connect_via(self, sender: t.Any, weak: bool = False) -> c.Callable[[F], F]:
+        """Connect the decorated function to be called when the signal is sent
+        by ``sender``.
+
+        The decorated function will be called when :meth:`send` is called with
+        the given ``sender``, passing ``sender`` as a positional argument along
+        with any extra keyword arguments.
+
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender. A receiver may be connected
+            to multiple senders by calling :meth:`connect` multiple times.
+        :param weak: Track the receiver with a :mod:`weakref`. The receiver will
+            be automatically disconnected when it is garbage collected. When
+            connecting a receiver defined within a function, set to ``False``,
+            otherwise it will be disconnected when the function scope ends.=
+
+        .. versionadded:: 1.1
+        """
+
+        def decorator(fn: F) -> F:
+            self.connect(fn, sender, weak)
+            return fn
+
+        return decorator
+
+    @contextmanager
+    def connected_to(
+        self, receiver: c.Callable[..., t.Any], sender: t.Any = ANY
+    ) -> c.Generator[None, None, None]:
+        """A context manager that temporarily connects ``receiver`` to the
+        signal while a ``with`` block executes. When the block exits, the
+        receiver is disconnected. Useful for tests.
+
+        :param receiver: The callable to call when :meth:`send` is called with
+            the given ``sender``, passing ``sender`` as a positional argument
+            along with any extra keyword arguments.
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender.
+
+        .. versionadded:: 1.1
+        """
+        self.connect(receiver, sender=sender, weak=False)
+
+        try:
+            yield None
+        finally:
+            self.disconnect(receiver)
+
+    @contextmanager
+    def muted(self) -> c.Generator[None, None, None]:
+        """A context manager that temporarily disables the signal. No receivers
+        will be called if the signal is sent, until the ``with`` block exits.
+        Useful for tests.
+        """
+        self.is_muted = True
+
+        try:
+            yield None
+        finally:
+            self.is_muted = False
+
+    def send(
+        self,
+        sender: t.Any | None = None,
+        /,
+        *,
+        _async_wrapper: c.Callable[
+            [c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]], c.Callable[..., t.Any]
+        ]
+        | None = None,
+        **kwargs: t.Any,
+    ) -> list[tuple[c.Callable[..., t.Any], t.Any]]:
+        """Call all receivers that are connected to the given ``sender``
+        or :data:`ANY`. Each receiver is called with ``sender`` as a positional
+        argument along with any extra keyword arguments. Return a list of
+        ``(receiver, return value)`` tuples.
+
+        The order receivers are called is undefined, but can be influenced by
+        setting :attr:`set_class`.
+
+        If a receiver raises an exception, that exception will propagate up.
+        This makes debugging straightforward, with an assumption that correctly
+        implemented receivers will not raise.
+
+        :param sender: Call receivers connected to this sender, in addition to
+            those connected to :data:`ANY`.
+        :param _async_wrapper: Will be called on any receivers that are async
+            coroutines to turn them into sync callables. For example, could run
+            the receiver with an event loop.
+        :param kwargs: Extra keyword arguments to pass to each receiver.
+
+        .. versionchanged:: 1.7
+            Added the ``_async_wrapper`` argument.
+        """
+        if self.is_muted:
+            return []
+
+        results = []
+
+        for receiver in self.receivers_for(sender):
+            if iscoroutinefunction(receiver):
+                if _async_wrapper is None:
+                    raise RuntimeError("Cannot send to a coroutine function.")
+
+                result = _async_wrapper(receiver)(sender, **kwargs)
+            else:
+                result = receiver(sender, **kwargs)
+
+            results.append((receiver, result))
+
+        return results
+
+    async def send_async(
+        self,
+        sender: t.Any | None = None,
+        /,
+        *,
+        _sync_wrapper: c.Callable[
+            [c.Callable[..., t.Any]], c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]
+        ]
+        | None = None,
+        **kwargs: t.Any,
+    ) -> list[tuple[c.Callable[..., t.Any], t.Any]]:
+        """Await all receivers that are connected to the given ``sender``
+        or :data:`ANY`. Each receiver is called with ``sender`` as a positional
+        argument along with any extra keyword arguments. Return a list of
+        ``(receiver, return value)`` tuples.
+
+        The order receivers are called is undefined, but can be influenced by
+        setting :attr:`set_class`.
+
+        If a receiver raises an exception, that exception will propagate up.
+        This makes debugging straightforward, with an assumption that correctly
+        implemented receivers will not raise.
+
+        :param sender: Call receivers connected to this sender, in addition to
+            those connected to :data:`ANY`.
+        :param _sync_wrapper: Will be called on any receivers that are sync
+            callables to turn them into async coroutines. For example,
+            could call the receiver in a thread.
+        :param kwargs: Extra keyword arguments to pass to each receiver.
+
+        .. versionadded:: 1.7
+        """
+        if self.is_muted:
+            return []
+
+        results = []
+
+        for receiver in self.receivers_for(sender):
+            if not iscoroutinefunction(receiver):
+                if _sync_wrapper is None:
+                    raise RuntimeError("Cannot send to a non-coroutine function.")
+
+                result = await _sync_wrapper(receiver)(sender, **kwargs)
+            else:
+                result = await receiver(sender, **kwargs)
+
+            results.append((receiver, result))
+
+        return results
+
+    def has_receivers_for(self, sender: t.Any) -> bool:
+        """Check if there is at least one receiver that will be called with the
+        given ``sender``. A receiver connected to :data:`ANY` will always be
+        called, regardless of sender. Does not check if weakly referenced
+        receivers are still live. See :meth:`receivers_for` for a stronger
+        search.
+
+        :param sender: Check for receivers connected to this sender, in addition
+            to those connected to :data:`ANY`.
+        """
+        if not self.receivers:
+            return False
+
+        if self._by_sender[ANY_ID]:
+            return True
+
+        if sender is ANY:
+            return False
+
+        return make_id(sender) in self._by_sender
+
+    def receivers_for(
+        self, sender: t.Any
+    ) -> c.Generator[c.Callable[..., t.Any], None, None]:
+        """Yield each receiver to be called for ``sender``, in addition to those
+        to be called for :data:`ANY`. Weakly referenced receivers that are not
+        live will be disconnected and skipped.
+
+        :param sender: Yield receivers connected to this sender, in addition
+            to those connected to :data:`ANY`.
+        """
+        # TODO: test receivers_for(ANY)
+        if not self.receivers:
+            return
+
+        sender_id = make_id(sender)
+
+        if sender_id in self._by_sender:
+            ids = self._by_sender[ANY_ID] | self._by_sender[sender_id]
+        else:
+            ids = self._by_sender[ANY_ID].copy()
+
+        for receiver_id in ids:
+            receiver = self.receivers.get(receiver_id)
+
+            if receiver is None:
+                continue
+
+            if isinstance(receiver, weakref.ref):
+                strong = receiver()
+
+                if strong is None:
+                    self._disconnect(receiver_id, ANY_ID)
+                    continue
+
+                yield strong
+            else:
+                yield receiver
+
+    def disconnect(self, receiver: c.Callable[..., t.Any], sender: t.Any = ANY) -> None:
+        """Disconnect ``receiver`` from being called when the signal is sent by
+        ``sender``.
+
+        :param receiver: A connected receiver callable.
+        :param sender: Disconnect from only this sender. By default, disconnect
+            from all senders.
+        """
+        sender_id: c.Hashable
+
+        if sender is ANY:
+            sender_id = ANY_ID
+        else:
+            sender_id = make_id(sender)
+
+        receiver_id = make_id(receiver)
+        self._disconnect(receiver_id, sender_id)
+
+        if (
+            "receiver_disconnected" in self.__dict__
+            and self.receiver_disconnected.receivers
+        ):
+            self.receiver_disconnected.send(self, receiver=receiver, sender=sender)
+
+    def _disconnect(self, receiver_id: c.Hashable, sender_id: c.Hashable) -> None:
+        if sender_id == ANY_ID:
+            if self._by_receiver.pop(receiver_id, None) is not None:
+                for bucket in self._by_sender.values():
+                    bucket.discard(receiver_id)
+
+            self.receivers.pop(receiver_id, None)
+        else:
+            self._by_sender[sender_id].discard(receiver_id)
+            self._by_receiver[receiver_id].discard(sender_id)
+
+    def _make_cleanup_receiver(
+        self, receiver_id: c.Hashable
+    ) -> c.Callable[[weakref.ref[c.Callable[..., t.Any]]], None]:
+        """Create a callback function to disconnect a weakly referenced
+        receiver when it is garbage collected.
+        """
+
+        def cleanup(ref: weakref.ref[c.Callable[..., t.Any]]) -> None:
+            # If the interpreter is shutting down, disconnecting can result in a
+            # weird ignored exception. Don't call it in that case.
+            if not sys.is_finalizing():
+                self._disconnect(receiver_id, ANY_ID)
+
+        return cleanup
+
+    def _make_cleanup_sender(
+        self, sender_id: c.Hashable
+    ) -> c.Callable[[weakref.ref[t.Any]], None]:
+        """Create a callback function to disconnect all receivers for a weakly
+        referenced sender when it is garbage collected.
+        """
+        assert sender_id != ANY_ID
+
+        def cleanup(ref: weakref.ref[t.Any]) -> None:
+            self._weak_senders.pop(sender_id, None)
+
+            for receiver_id in self._by_sender.pop(sender_id, ()):
+                self._by_receiver[receiver_id].discard(sender_id)
+
+        return cleanup
+
+    def _cleanup_bookkeeping(self) -> None:
+        """Prune unused sender/receiver bookkeeping. Not threadsafe.
+
+        Connecting & disconnecting leaves behind a small amount of bookkeeping
+        data. Typical workloads using Blinker, for example in most web apps,
+        Flask, CLI scripts, etc., are not adversely affected by this
+        bookkeeping.
+
+        With a long-running process performing dynamic signal routing with high
+        volume, e.g. connecting to function closures, senders are all unique
+        object instances. Doing all of this over and over may cause memory usage
+        to grow due to extraneous bookkeeping. (An empty ``set`` for each stale
+        sender/receiver pair.)
+
+        This method will prune that bookkeeping away, with the caveat that such
+        pruning is not threadsafe. The risk is that cleanup of a fully
+        disconnected receiver/sender pair occurs while another thread is
+        connecting that same pair. If you are in the highly dynamic, unique
+        receiver/sender situation that has lead you to this method, that failure
+        mode is perhaps not a big deal for you.
+        """
+        for mapping in (self._by_sender, self._by_receiver):
+            for ident, bucket in list(mapping.items()):
+                if not bucket:
+                    mapping.pop(ident, None)
+
+    def _clear_state(self) -> None:
+        """Disconnect all receivers and senders. Useful for tests."""
+        self._weak_senders.clear()
+        self.receivers.clear()
+        self._by_sender.clear()
+        self._by_receiver.clear()
+
+
+class NamedSignal(Signal):
+    """A named generic notification emitter. The name is not used by the signal
+    itself, but matches the key in the :class:`Namespace` that it belongs to.
+
+    :param name: The name of the signal within the namespace.
+    :param doc: The docstring for the signal.
+    """
+
+    def __init__(self, name: str, doc: str | None = None) -> None:
+        super().__init__(doc)
+
+        #: The name of this signal.
+        self.name: str = name
+
+    def __repr__(self) -> str:
+        base = super().__repr__()
+        return f"{base[:-1]}; {self.name!r}>"  # noqa: E702
+
+
+class Namespace(dict[str, NamedSignal]):
+    """A dict mapping names to signals."""
+
+    def signal(self, name: str, doc: str | None = None) -> NamedSignal:
+        """Return the :class:`NamedSignal` for the given ``name``, creating it
+        if required. Repeated calls with the same name return the same signal.
+
+        :param name: The name of the signal.
+        :param doc: The docstring of the signal.
+        """
+        if name not in self:
+            self[name] = NamedSignal(name, doc)
+
+        return self[name]
+
+
+class _PNamespaceSignal(t.Protocol):
+    def __call__(self, name: str, doc: str | None = None) -> NamedSignal: ...
+
+
+default_namespace: Namespace = Namespace()
+"""A default :class:`Namespace` for creating named signals. :func:`signal`
+creates a :class:`NamedSignal` in this namespace.
+"""
+
+signal: _PNamespaceSignal = default_namespace.signal
+"""Return a :class:`NamedSignal` in :data:`default_namespace` with the given
+``name``, creating it if required. Repeated calls with the same name return the
+same signal.
+"""

venv/lib/python3.12/site-packages/certifi-2026.6.17.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/lib/python3.12/site-packages/certifi-2026.6.17.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: certifi
+Version: 2026.6.17
+Summary: Python package for providing Mozilla's CA Bundle.
+Home-page: https://github.com/certifi/python-certifi
+Author: Kenneth Reitz
+Author-email: me@kennethreitz.com
+License: MPL-2.0
+Project-URL: Source, https://github.com/certifi/python-certifi
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.7
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+Certifi: Python SSL Certificates
+================================
+
+Certifi provides Mozilla's carefully curated collection of Root Certificates for
+validating the trustworthiness of SSL certificates while verifying the identity
+of TLS hosts. It has been extracted from the `Requests`_ project.
+
+Installation
+------------
+
+``certifi`` is available on PyPI. Simply install it with ``pip``::
+
+    $ pip install certifi
+
+Usage
+-----
+
+To reference the installed certificate authority (CA) bundle, you can use the
+built-in function::
+
+    >>> import certifi
+
+    >>> certifi.where()
+    '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem'
+
+Or from the command line::
+
+    $ python -m certifi
+    /usr/local/lib/python3.7/site-packages/certifi/cacert.pem
+
+Enjoy!
+
+.. _`Requests`: https://requests.readthedocs.io/en/latest/
+
+Addition/Removal of Certificates
+--------------------------------
+
+Certifi does not support any addition/removal or other modification of the
+CA trust store content. This project is intended to provide a reliable and
+highly portable root of trust to python deployments. Look to upstream projects
+for methods to use alternate trust.

venv/lib/python3.12/site-packages/certifi-2026.6.17.dist-info/RECORD

@@ -0,0 +1,14 @@
+certifi-2026.6.17.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+certifi-2026.6.17.dist-info/METADATA,sha256=6hXAnt0a2el7xm2e9xvPuRCntZLjdKCkN81e47E0wN8,2474
+certifi-2026.6.17.dist-info/RECORD,,
+certifi-2026.6.17.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+certifi-2026.6.17.dist-info/licenses/LICENSE,sha256=6TcW2mucDVpKHfYP5pWzcPBpVgPSH2-D8FPkLPwQyvc,989
+certifi-2026.6.17.dist-info/top_level.txt,sha256=KMu4vUCfsjLrkPbSNdgdekS-pVJzBAJFO__nI8NF6-U,8
+certifi/__init__.py,sha256=-W1R_y8WCaSkT1tdjuxH_zTBZY1YH6xQgdN1nbBajOE,94
+certifi/__main__.py,sha256=xBBoj905TUWBLRGANOcf7oi6e-3dMP4cEoG9OyMs11g,243
+certifi/__pycache__/__init__.cpython-312.pyc,,
+certifi/__pycache__/__main__.cpython-312.pyc,,
+certifi/__pycache__/core.cpython-312.pyc,,
+certifi/cacert.pem,sha256=u8fpwB11UbuKFZtd7dmJuO484QWv9SK2jrGwG_hUyrA,234354
+certifi/core.py,sha256=XFXycndG5pf37ayeF8N32HUuDafsyhkVMbO4BAPWHa0,3394
+certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

venv/lib/python3.12/site-packages/certifi-2026.6.17.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

venv/lib/python3.12/site-packages/certifi-2026.6.17.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+This package contains a modified version of ca-bundle.crt:
+
+ca-bundle.crt -- Bundle of CA Root Certificates
+
+This is a bundle of X.509 certificates of public Certificate Authorities
+(CA). These were automatically extracted from Mozilla's root certificates
+file (certdata.txt).  This file can be found in the mozilla source tree:
+https://hg.mozilla.org/mozilla-central/file/tip/security/nss/lib/ckfw/builtins/certdata.txt
+It contains the certificates in PEM format and therefore
+can be directly used with curl / libcurl / php_curl, or with
+an Apache+mod_ssl webserver for SSL client authentication.
+Just configure this file as the SSLCACertificateFile.#
+
+***** BEGIN LICENSE BLOCK *****
+This Source Code Form is subject to the terms of the Mozilla Public License,
+v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
+one at http://mozilla.org/MPL/2.0/.
+
+***** END LICENSE BLOCK *****
+@(#) $RCSfile: certdata.txt,v $ $Revision: 1.80 $ $Date: 2011/11/03 15:11:58 $

venv/lib/python3.12/site-packages/certifi-2026.6.17.dist-info/top_level.txt

@@ -0,0 +1 @@
+certifi

venv/lib/python3.12/site-packages/certifi/__init__.py

@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2026.06.17"

venv/lib/python3.12/site-packages/certifi/__main__.py

@@ -0,0 +1,12 @@
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())

venv/lib/python3.12/site-packages/certifi/core.py

@@ -0,0 +1,83 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import sys
+import atexit
+
+def exit_cacert_ctx() -> None:
+    _CACERT_CTX.__exit__(None, None, None)  # type: ignore[union-attr]
+
+
+if sys.version_info >= (3, 11):
+
+    from importlib.resources import as_file, files
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = as_file(files("certifi").joinpath("cacert.pem"))
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return files("certifi").joinpath("cacert.pem").read_text(encoding="ascii")
+
+else:
+
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the
+        # file in cases where we're inside of a zipimport situation until
+        # someone actually calls where(), but we don't want to re-extract
+        # the file on every call of where(), so we'll do it once then store
+        # it in a global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you
+            # to manage the cleanup of this file, so it doesn't actually
+            # return a path, it returns a context manager that will give
+            # you the path when you enter it and will do any cleanup when
+            # you leave it. In the common case of not needing a temporary
+            # file, it will just return the file system location and the
+            # __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")

venv/lib/python3.12/site-packages/charset_normalizer-3.4.9.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/lib/python3.12/site-packages/charset_normalizer-3.4.9.dist-info/METADATA

@@ -0,0 +1,827 @@
+Metadata-Version: 2.4
+Name: charset-normalizer
+Version: 3.4.9
+Summary: The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet.
+Author-email: "Ahmed R. TAHRI" <tahri.ahmed@proton.me>
+Maintainer-email: "Ahmed R. TAHRI" <tahri.ahmed@proton.me>
+License: MIT
+Project-URL: Changelog, https://github.com/jawah/charset_normalizer/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://charset-normalizer.readthedocs.io/
+Project-URL: Code, https://github.com/jawah/charset_normalizer
+Project-URL: Issue tracker, https://github.com/jawah/charset_normalizer/issues
+Keywords: encoding,charset,charset-detector,detector,normalization,unicode,chardet,detect
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Free Threading :: 4 - Resilient
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: unicode-backport
+Dynamic: license-file
+
+<h1 align="center">Charset Detection, for Everyone 👋</h1>
+
+<p align="center">
+  <sup>The Real First Universal Charset Detector</sup><br>
+  <a href="https://pypi.org/project/charset-normalizer">
+    <img src="https://img.shields.io/pypi/pyversions/charset_normalizer.svg?orange=blue" />
+  </a>
+  <a href="https://pepy.tech/project/charset-normalizer/">
+    <img alt="Download Count Total" src="https://static.pepy.tech/badge/charset-normalizer/month" />
+  </a>
+  <a href="https://bestpractices.coreinfrastructure.org/projects/7297">
+    <img src="https://bestpractices.coreinfrastructure.org/projects/7297/badge">
+  </a>
+</p>
+<p align="center">
+  <sup><i>Featured Packages</i></sup><br>
+  <a href="https://github.com/jawah/niquests">
+   <img alt="Static Badge" src="https://img.shields.io/badge/Niquests-Most_Advanced_HTTP_Client-cyan">
+  </a>
+  <a href="https://github.com/jawah/wassima">
+   <img alt="Static Badge" src="https://img.shields.io/badge/Wassima-Certifi_Replacement-cyan">
+  </a>
+</p>
+<p align="center">
+  <sup><i>In other language (unofficial port - by the community)</i></sup><br>
+  <a href="https://github.com/nickspring/charset-normalizer-rs">
+   <img alt="Static Badge" src="https://img.shields.io/badge/Rust-red">
+  </a>
+</p>
+
+> A library that helps you read text from an unknown charset encoding.<br /> Motivated by `chardet`,
+> I'm trying to resolve the issue by taking a new approach.
+> All IANA character set names for which the Python core library provides codecs are supported.
+> You can also register your own set of codecs, and yes, it would work as-is.
+
+This project offers you an alternative to **Universal Charset Encoding Detector**, also known as **Chardet**.
+
+| Feature                                          | [Chardet](https://github.com/chardet/chardet) |                                       Charset Normalizer                                        | [cChardet](https://github.com/PyYoshi/cChardet) |
+|--------------------------------------------------|:---------------------------------------------:|:-----------------------------------------------------------------------------------------------:|:-----------------------------------------------:|
+| `Fast`                                           |                       ✅                       |                                                ✅                                                |                        ✅                        |
+| `Universal`[^1]                                  |                       ❌                       |                                                ✅                                                |                        ❌                        |
+| `Reliable` **without** distinguishable standards |                       ✅                       |                                                ✅                                                |                        ✅                        |
+| `Reliable` **with** distinguishable standards    |                       ✅                       |                                                ✅                                                |                        ✅                        |
+| `License`                                        |        _Disputed_[^2]<br>_restrictive_        |                                               MIT                                               |            MPL-1.1<br>_restrictive_             |
+| `Native Python`                                  |                       ✅                       |                                                ✅                                                |                        ❌                        |
+| `Detect spoken language`                         |                       ✅                       |                                                ✅                                                |                       N/A                       |
+| `UnicodeDecodeError Safety`                      |                       ✅                       |                                                ✅                                                |                        ❌                        |
+| `Whl Size (min)`                                 |                    500 kB                     |                                             150 kB                                              |                     ~200 kB                     |
+| `Supported Encoding`                             |                      99                       | [99](https://charset-normalizer.readthedocs.io/en/latest/user/support.html#supported-encodings) |                       40                        |
+| `Can register custom encoding`                   |                       ❌                       |                                                ✅                                                |                        ❌                        |
+
+<p align="center">
+<img src="https://i.imgflip.com/373iay.gif" alt="Reading Normalized Text" width="226"/><img src="https://media.tenor.com/images/c0180f70732a18b4965448d33adba3d0/tenor.gif" alt="Cat Reading Text" width="200"/>
+</p>
+
+[^1]: They are clearly using specific code for a specific encoding even if covering most of used one.
+[^2]: Chardet 7.0+ was relicensed from LGPL-2.1 to MIT following an AI-assisted rewrite. This relicensing is disputed on two independent grounds: **(a)** the original author [contests](https://github.com/chardet/chardet/issues/327) that the maintainer had the right to relicense, arguing the rewrite is a derivative work of the LGPL-licensed codebase since it was not a clean room implementation; **(b)** the copyright claim itself is [questionable](https://github.com/chardet/chardet/issues/334) given the code was primarily generated by an LLM, and AI-generated output may not be copyrightable under most jurisdictions. Either issue alone could undermine the MIT license. Beyond licensing, the rewrite raises questions about responsible use of AI in open source: key architectural ideas pioneered by charset-normalizer - notably decode-first validity filtering (our foundational approach since v1) and encoding pairwise similarity with the same algorithm and threshold — surfaced in chardet 7 without acknowledgment. The project also imported test files from charset-normalizer to train and benchmark against it, then claimed superior accuracy on those very files. Charset-normalizer has always been MIT-licensed, encoding-agnostic by design, and built on a verifiable human-authored history.
+
+## ⚡ Performance
+
+This package offer better performances against Chardet. Here are some numbers.
+
+| Package                                           | Accuracy | Mean per file (ms) | File per sec (est) |
+|---------------------------------------------------|:--------:|:------------------:|:------------------:|
+| [chardet 7.4](https://github.com/chardet/chardet) |   89 %   |        3 ms        |    333 file/sec    |
+| charset-normalizer                                | **97 %** |        1 ms        |   1000 file/sec    |
+
+| Package                                           | 99th percentile | 95th percentile | 50th percentile |
+|---------------------------------------------------|:---------------:|:---------------:|:---------------:|
+| [chardet 7.4](https://github.com/chardet/chardet) |      28 ms      |      16 ms      |     < 1 ms      |
+| charset-normalizer                                |      8 ms       |      5 ms       |      1 ms       |
+
+_updated as of July 2026 using CPython 3.12, Charset-Normalizer 3.4.8, and Chardet 7.4.3_
+
+~Chardet's performance on larger file (1MB+) are very poor. Expect huge difference on large payload.~ No longer the case since Chardet 7.0+
+
+> Stats are generated using 400+ files using default parameters. More details on used files, see GHA workflows.
+> And yes, these results might change at any time. The dataset can be updated to include more files.
+> The actual delays heavily depends on your CPU capabilities. The factors should remain the same.
+> Chardet claims on his documentation to have a greater accuracy than us based on the dataset they trained Chardet on(...)
+> Well, it's normal, the opposite would have been worrying. Whereas charset-normalizer don't train on anything, our solution
+> is based on a completely different algorithm, still heuristic through, it does not need weights across every encoding tables.
+
+## ✨ Installation
+
+Using pip:
+
+```sh
+pip install charset-normalizer -U
+```
+
+## 🚀 Basic Usage
+
+### CLI
+This package comes with a CLI.
+
+```
+usage: normalizer [-h] [-v] [-a] [-n] [-m] [-r] [-f] [-t THRESHOLD]
+                  file [file ...]
+
+The Real First Universal Charset Detector. Discover originating encoding used
+on text file. Normalize text to unicode.
+
+positional arguments:
+  files                 File(s) to be analysed
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -v, --verbose         Display complementary information about file if any.
+                        Stdout will contain logs about the detection process.
+  -a, --with-alternative
+                        Output complementary possibilities if any. Top-level
+                        JSON WILL be a list.
+  -n, --normalize       Permit to normalize input file. If not set, program
+                        does not write anything.
+  -m, --minimal         Only output the charset detected to STDOUT. Disabling
+                        JSON output.
+  -r, --replace         Replace file when trying to normalize it instead of
+                        creating a new one.
+  -f, --force           Replace file without asking if you are sure, use this
+                        flag with caution.
+  -t THRESHOLD, --threshold THRESHOLD
+                        Define a custom maximum amount of chaos allowed in
+                        decoded content. 0. <= chaos <= 1.
+  --version             Show version information and exit.
+```
+
+```bash
+normalizer ./data/sample.1.fr.srt
+```
+
+or
+
+```bash
+python -m charset_normalizer ./data/sample.1.fr.srt
+```
+
+🎉 Since version 1.4.0 the CLI produce easily usable stdout result in JSON format.
+
+```json
+{
+    "path": "/home/default/projects/charset_normalizer/data/sample.1.fr.srt",
+    "encoding": "cp1252",
+    "encoding_aliases": [
+        "1252",
+        "windows_1252"
+    ],
+    "alternative_encodings": [
+        "cp1254",
+        "cp1256",
+        "cp1258",
+        "iso8859_14",
+        "iso8859_15",
+        "iso8859_16",
+        "iso8859_3",
+        "iso8859_9",
+        "latin_1",
+        "mbcs"
+    ],
+    "language": "French",
+    "alphabets": [
+        "Basic Latin",
+        "Latin-1 Supplement"
+    ],
+    "has_sig_or_bom": false,
+    "chaos": 0.149,
+    "coherence": 97.152,
+    "unicode_path": null,
+    "is_preferred": true
+}
+```
+
+### Python
+*Just print out normalized text*
+```python
+from charset_normalizer import from_path
+
+results = from_path('./my_subtitle.srt')
+
+print(str(results.best()))
+```
+
+*Upgrade your code without effort*
+```python
+from charset_normalizer import detect
+```
+
+The above code will behave the same as **chardet**. We ensure that we offer the best (reasonable) BC result possible.
+
+See the docs for advanced usage : [readthedocs.io](https://charset-normalizer.readthedocs.io/en/latest/)
+
+## 😇 Why
+
+When I started using Chardet, I noticed that it was not suited to my expectations, and I wanted to propose a
+reliable alternative using a completely different method. Also! I never back down on a good challenge!
+
+I **don't care** about the **originating charset** encoding, because **two different tables** can
+produce **two identical rendered string.**
+What I want is to get readable text, the best I can.
+
+In a way, **I'm brute forcing text decoding.** How cool is that ? 😎
+
+Don't confuse package **ftfy** with charset-normalizer or chardet. ftfy goal is to repair Unicode string whereas charset-normalizer to convert raw file in unknown encoding to unicode.
+
+## 🍰 How
+
+  - Discard all charset encoding table that could not fit the binary content.
+  - Measure noise, or the mess once opened (by chunks) with a corresponding charset encoding.
+  - Extract matches with the lowest mess detected.
+  - Additionally, we measure coherence / probe for a language.
+
+**Wait a minute**, what is noise/mess and coherence according to **YOU ?**
+
+*Noise :* I opened hundred of text files, **written by humans**, with the wrong encoding table. **I observed**, then
+**I established** some ground rules about **what is obvious** when **it seems like** a mess (aka. defining noise in rendered text).
+ I know that my interpretation of what is noise is probably incomplete, feel free to contribute in order to
+ improve or rewrite it.
+
+*Coherence :* For each language there is on earth, we have computed ranked letter appearance occurrences (the best we can). So I thought
+that intel is worth something here. So I use those records against decoded text to check if I can detect intelligent design.
+
+## ⚡ Known limitations
+
+  - Language detection is unreliable when text contains two or more languages sharing identical letters. (eg. HTML (english tags) + Turkish content (Sharing Latin characters))
+  - Every charset detector heavily depends on sufficient content. In common cases, do not bother run detection on very tiny content.
+
+## ⚠️ About Python EOLs
+
+**If you are running:**
+
+- Python >=2.7,<3.5: Unsupported
+- Python 3.5: charset-normalizer < 2.1
+- Python 3.6: charset-normalizer < 3.1
+
+Upgrade your Python interpreter as soon as possible.
+
+## 👤 Contributing
+
+Contributions, issues and feature requests are very much welcome.<br />
+Feel free to check [issues page](https://github.com/ousret/charset_normalizer/issues) if you want to contribute.
+
+## 📝 License
+
+Copyright © [Ahmed TAHRI @Ousret](https://github.com/Ousret).<br />
+This project is [MIT](https://github.com/Ousret/charset_normalizer/blob/master/LICENSE) licensed.
+
+Characters frequencies used in this project © 2012 [Denny Vrandečić](http://simia.net/letters/)
+
+## 💼 For Enterprise
+
+Professional support for charset-normalizer is available as part of the [Tidelift
+Subscription][1]. Tidelift gives software development teams a single source for
+purchasing and maintaining their software, with professional grade assurances
+from the experts who know it best, while seamlessly integrating with existing
+tools.
+
+[1]: https://tidelift.com/subscription/pkg/pypi-charset-normalizer?utm_source=pypi-charset-normalizer&utm_medium=readme
+
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/7297/badge)](https://www.bestpractices.dev/projects/7297)
+
+# Changelog
+All notable changes to charset-normalizer will be documented in this file. This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [3.4.9](https://github.com/Ousret/charset_normalizer/compare/3.4.8...3.4.9) (2026-07-07)
+
+### Fixed
+- Regression in our fallback path leading to a decode error. (#771)
+  We've yanked 3.4.8 as a result of that bug.
+
+## [3.4.8](https://github.com/Ousret/charset_normalizer/compare/3.4.7...3.4.8) (2026-07-06)
+
+### Fixed
+- Wall import time due to cascade codec imports for our multibyte first sort of iana supported codecs (#742)
+- Unnecessary json import at runtime (#753)
+- Inverse capitalization not seen by noise detector (#731)
+
+### Changed
+- No longer holding a global cache for our noise / coherence measurements. Relax RSS memory usage.
+- Micro-optimizations in our noise / coherence measurements.
+- No longer using regex search by default for our preemptive charset mark algorithm.
+- Raised upperbound of setuptools to v83.
+- Raised upperbound of mypy(c) to v2.1.
+
+### Removed
+- Redundant UTF7 BOM marker (#730)
+
+## [3.4.7](https://github.com/Ousret/charset_normalizer/compare/3.4.6...3.4.7) (2026-04-02)
+
+### Changed
+- Pre-built optimized version using mypy[c] v1.20.
+- Relax `setuptools` constraint to `setuptools>=68,<82.1`.
+
+### Fixed
+- Correctly remove SIG remnant in utf-7 decoded string. (#718) (#716)
+
+## [3.4.6](https://github.com/Ousret/charset_normalizer/compare/3.4.5...3.4.6) (2026-03-15)
+
+### Changed
+- Flattened the logic in `charset_normalizer.md` for higher performance. Removed `eligible(..)` and `feed(...)`
+  in favor of `feed_info(...)`.
+- Raised upper bound for mypy[c] to 1.20, for our optimized version.
+- Updated `UNICODE_RANGES_COMBINED` using Unicode blocks v17.
+
+### Fixed
+- Edge case where noise difference between two candidates can be almost insignificant. (#672)
+- CLI `--normalize` writing to wrong path when passing multiple files in. (#702)
+
+### Misc
+- Freethreaded pre-built wheels now shipped in PyPI starting with 3.14t. (#616)
+
+## [3.4.5](https://github.com/Ousret/charset_normalizer/compare/3.4.4...3.4.5) (2026-03-06)
+
+### Changed
+- Update `setuptools` constraint to `setuptools>=68,<=82`.
+- Raised upper bound of mypyc for the optional pre-built extension to v1.19.1
+
+### Fixed
+- Add explicit link to lib math in our optimized build. (#692)
+- Logger level not restored correctly for empty byte sequences. (#701)
+- TypeError when passing bytearray to from_bytes. (#703)
+
+### Misc
+- Applied safe micro-optimizations in both our noise detector and language detector.
+- Rewrote the `query_yes_no` function (inside CLI) to avoid using ambiguous licensed code.
+- Added `cd.py` submodule into mypyc optional compilation to reduce further the performance impact.
+
+## [3.4.4](https://github.com/Ousret/charset_normalizer/compare/3.4.2...3.4.4) (2025-10-13)
+
+### Changed
+- Bound `setuptools` to a specific constraint `setuptools>=68,<=81`.
+- Raised upper bound of mypyc for the optional pre-built extension to v1.18.2
+
+### Removed
+- `setuptools-scm` as a build dependency.
+
+### Misc
+- Enforced hashes in `dev-requirements.txt` and created `ci-requirements.txt` for security purposes.
+- Additional pre-built wheels for riscv64, s390x, and armv7l architectures.
+- Restore ` multiple.intoto.jsonl` in GitHub releases in addition to individual attestation file per wheel.
+
+## [3.4.3](https://github.com/Ousret/charset_normalizer/compare/3.4.2...3.4.3) (2025-08-09)
+
+### Changed
+- mypy(c) is no longer a required dependency at build time if `CHARSET_NORMALIZER_USE_MYPYC` isn't set to `1`. (#595) (#583)
+- automatically lower confidence on small bytes samples that are not Unicode in `detect` output legacy function. (#391)
+
+### Added
+- Custom build backend to overcome inability to mark mypy as an optional dependency in the build phase.
+- Support for Python 3.14
+
+### Fixed
+- sdist archive contained useless directories.
+- automatically fallback on valid UTF-16 or UTF-32 even if the md says it's noisy. (#633)
+
+### Misc
+- SBOM are automatically published to the relevant GitHub release to comply with regulatory changes.
+  Each published wheel comes with its SBOM. We choose CycloneDX as the format.
+- Prebuilt optimized wheel are no longer distributed by default for CPython 3.7 due to a change in cibuildwheel.
+
+## [3.4.2](https://github.com/Ousret/charset_normalizer/compare/3.4.1...3.4.2) (2025-05-02)
+
+### Fixed
+- Addressed the DeprecationWarning in our CLI regarding `argparse.FileType` by backporting the target class into the package. (#591)
+- Improved the overall reliability of the detector with CJK Ideographs. (#605) (#587)
+
+### Changed
+- Optional mypyc compilation upgraded to version 1.15 for Python >= 3.8
+
+## [3.4.1](https://github.com/Ousret/charset_normalizer/compare/3.4.0...3.4.1) (2024-12-24)
+
+### Changed
+- Project metadata are now stored using `pyproject.toml` instead of `setup.cfg` using setuptools as the build backend.
+- Enforce annotation delayed loading for a simpler and consistent types in the project.
+- Optional mypyc compilation upgraded to version 1.14 for Python >= 3.8
+
+### Added
+- pre-commit configuration.
+- noxfile.
+
+### Removed
+- `build-requirements.txt` as per using `pyproject.toml` native build configuration.
+- `bin/integration.py` and `bin/serve.py` in favor of downstream integration test (see noxfile).
+- `setup.cfg` in favor of `pyproject.toml` metadata configuration.
+- Unused `utils.range_scan` function.
+
+### Fixed
+- Converting content to Unicode bytes may insert `utf_8` instead of preferred `utf-8`. (#572)
+- Deprecation warning "'count' is passed as positional argument" when converting to Unicode bytes on Python 3.13+
+
+## [3.4.0](https://github.com/Ousret/charset_normalizer/compare/3.3.2...3.4.0) (2024-10-08)
+
+### Added
+- Argument `--no-preemptive` in the CLI to prevent the detector to search for hints.
+- Support for Python 3.13 (#512)
+
+### Fixed
+- Relax the TypeError exception thrown when trying to compare a CharsetMatch with anything else than a CharsetMatch.
+- Improved the general reliability of the detector based on user feedbacks. (#520) (#509) (#498) (#407) (#537)
+- Declared charset in content (preemptive detection) not changed when converting to utf-8 bytes. (#381)
+
+## [3.3.2](https://github.com/Ousret/charset_normalizer/compare/3.3.1...3.3.2) (2023-10-31)
+
+### Fixed
+- Unintentional memory usage regression when using large payload that match several encoding (#376)
+- Regression on some detection case showcased in the documentation (#371)
+
+### Added
+- Noise (md) probe that identify malformed arabic representation due to the presence of letters in isolated form (credit to my wife)
+
+## [3.3.1](https://github.com/Ousret/charset_normalizer/compare/3.3.0...3.3.1) (2023-10-22)
+
+### Changed
+- Optional mypyc compilation upgraded to version 1.6.1 for Python >= 3.8
+- Improved the general detection reliability based on reports from the community
+
+## [3.3.0](https://github.com/Ousret/charset_normalizer/compare/3.2.0...3.3.0) (2023-09-30)
+
+### Added
+- Allow to execute the CLI (e.g. normalizer) through `python -m charset_normalizer.cli` or `python -m charset_normalizer`
+- Support for 9 forgotten encoding that are supported by Python but unlisted in `encoding.aliases` as they have no alias (#323)
+
+### Removed
+- (internal) Redundant utils.is_ascii function and unused function is_private_use_only
+- (internal) charset_normalizer.assets is moved inside charset_normalizer.constant
+
+### Changed
+- (internal) Unicode code blocks in constants are updated using the latest v15.0.0 definition to improve detection
+- Optional mypyc compilation upgraded to version 1.5.1 for Python >= 3.8
+
+### Fixed
+- Unable to properly sort CharsetMatch when both chaos/noise and coherence were close due to an unreachable condition in \_\_lt\_\_ (#350)
+
+## [3.2.0](https://github.com/Ousret/charset_normalizer/compare/3.1.0...3.2.0) (2023-06-07)
+
+### Changed
+- Typehint for function `from_path` no longer enforce `PathLike` as its first argument
+- Minor improvement over the global detection reliability
+
+### Added
+- Introduce function `is_binary` that relies on main capabilities, and optimized to detect binaries
+- Propagate `enable_fallback` argument throughout `from_bytes`, `from_path`, and `from_fp` that allow a deeper control over the detection (default True)
+- Explicit support for Python 3.12
+
+### Fixed
+- Edge case detection failure where a file would contain 'very-long' camel cased word (Issue #289)
+
+## [3.1.0](https://github.com/Ousret/charset_normalizer/compare/3.0.1...3.1.0) (2023-03-06)
+
+### Added
+- Argument `should_rename_legacy` for legacy function `detect` and disregard any new arguments without errors (PR #262)
+
+### Removed
+- Support for Python 3.6 (PR #260)
+
+### Changed
+- Optional speedup provided by mypy/c 1.0.1
+
+## [3.0.1](https://github.com/Ousret/charset_normalizer/compare/3.0.0...3.0.1) (2022-11-18)
+
+### Fixed
+- Multi-bytes cutter/chunk generator did not always cut correctly (PR #233)
+
+### Changed
+- Speedup provided by mypy/c 0.990 on Python >= 3.7
+
+## [3.0.0](https://github.com/Ousret/charset_normalizer/compare/2.1.1...3.0.0) (2022-10-20)
+
+### Added
+- Extend the capability of explain=True when cp_isolation contains at most two entries (min one), will log in details of the Mess-detector results
+- Support for alternative language frequency set in charset_normalizer.assets.FREQUENCIES
+- Add parameter `language_threshold` in `from_bytes`, `from_path` and `from_fp` to adjust the minimum expected coherence ratio
+- `normalizer --version` now specify if current version provide extra speedup (meaning mypyc compilation whl)
+
+### Changed
+- Build with static metadata using 'build' frontend
+- Make the language detection stricter
+- Optional: Module `md.py` can be compiled using Mypyc to provide an extra speedup up to 4x faster than v2.1
+
+### Fixed
+- CLI with opt --normalize fail when using full path for files
+- TooManyAccentuatedPlugin induce false positive on the mess detection when too few alpha character have been fed to it
+- Sphinx warnings when generating the documentation
+
+### Removed
+- Coherence detector no longer return 'Simple English' instead return 'English'
+- Coherence detector no longer return 'Classical Chinese' instead return 'Chinese'
+- Breaking: Method `first()` and `best()` from CharsetMatch
+- UTF-7 will no longer appear as "detected" without a recognized SIG/mark (is unreliable/conflict with ASCII)
+- Breaking: Class aliases CharsetDetector, CharsetDoctor, CharsetNormalizerMatch and CharsetNormalizerMatches
+- Breaking: Top-level function `normalize`
+- Breaking: Properties `chaos_secondary_pass`, `coherence_non_latin` and `w_counter` from CharsetMatch
+- Support for the backport `unicodedata2`
+
+## [3.0.0rc1](https://github.com/Ousret/charset_normalizer/compare/3.0.0b2...3.0.0rc1) (2022-10-18)
+
+### Added
+- Extend the capability of explain=True when cp_isolation contains at most two entries (min one), will log in details of the Mess-detector results
+- Support for alternative language frequency set in charset_normalizer.assets.FREQUENCIES
+- Add parameter `language_threshold` in `from_bytes`, `from_path` and `from_fp` to adjust the minimum expected coherence ratio
+
+### Changed
+- Build with static metadata using 'build' frontend
+- Make the language detection stricter
+
+### Fixed
+- CLI with opt --normalize fail when using full path for files
+- TooManyAccentuatedPlugin induce false positive on the mess detection when too few alpha character have been fed to it
+
+### Removed
+- Coherence detector no longer return 'Simple English' instead return 'English'
+- Coherence detector no longer return 'Classical Chinese' instead return 'Chinese'
+
+## [3.0.0b2](https://github.com/Ousret/charset_normalizer/compare/3.0.0b1...3.0.0b2) (2022-08-21)
+
+### Added
+- `normalizer --version` now specify if current version provide extra speedup (meaning mypyc compilation whl)
+
+### Removed
+- Breaking: Method `first()` and `best()` from CharsetMatch
+- UTF-7 will no longer appear as "detected" without a recognized SIG/mark (is unreliable/conflict with ASCII)
+
+### Fixed
+- Sphinx warnings when generating the documentation
+
+## [3.0.0b1](https://github.com/Ousret/charset_normalizer/compare/2.1.0...3.0.0b1) (2022-08-15)
+
+### Changed
+- Optional: Module `md.py` can be compiled using Mypyc to provide an extra speedup up to 4x faster than v2.1
+
+### Removed
+- Breaking: Class aliases CharsetDetector, CharsetDoctor, CharsetNormalizerMatch and CharsetNormalizerMatches
+- Breaking: Top-level function `normalize`
+- Breaking: Properties `chaos_secondary_pass`, `coherence_non_latin` and `w_counter` from CharsetMatch
+- Support for the backport `unicodedata2`
+
+## [2.1.1](https://github.com/Ousret/charset_normalizer/compare/2.1.0...2.1.1) (2022-08-19)
+
+### Deprecated
+- Function `normalize` scheduled for removal in 3.0
+
+### Changed
+- Removed useless call to decode in fn is_unprintable (#206)
+
+### Fixed
+- Third-party library (i18n xgettext) crashing not recognizing utf_8 (PEP 263) with underscore from [@aleksandernovikov](https://github.com/aleksandernovikov) (#204)
+
+## [2.1.0](https://github.com/Ousret/charset_normalizer/compare/2.0.12...2.1.0) (2022-06-19)
+
+### Added
+- Output the Unicode table version when running the CLI with `--version` (PR #194)
+
+### Changed
+- Reuse decoded buffer for single byte character sets from [@nijel](https://github.com/nijel) (PR #175)
+- Fixing some performance bottlenecks from [@deedy5](https://github.com/deedy5) (PR #183)
+
+### Fixed
+- Workaround potential bug in cpython with Zero Width No-Break Space located in Arabic Presentation Forms-B, Unicode 1.1 not acknowledged as space (PR #175)
+- CLI default threshold aligned with the API threshold from [@oleksandr-kuzmenko](https://github.com/oleksandr-kuzmenko) (PR #181)
+
+### Removed
+- Support for Python 3.5 (PR #192)
+
+### Deprecated
+- Use of backport unicodedata from `unicodedata2` as Python is quickly catching up, scheduled for removal in 3.0 (PR #194)
+
+## [2.0.12](https://github.com/Ousret/charset_normalizer/compare/2.0.11...2.0.12) (2022-02-12)
+
+### Fixed
+- ASCII miss-detection on rare cases (PR #170)
+
+## [2.0.11](https://github.com/Ousret/charset_normalizer/compare/2.0.10...2.0.11) (2022-01-30)
+
+### Added
+- Explicit support for Python 3.11 (PR #164)
+
+### Changed
+- The logging behavior have been completely reviewed, now using only TRACE and DEBUG levels (PR #163 #165)
+
+## [2.0.10](https://github.com/Ousret/charset_normalizer/compare/2.0.9...2.0.10) (2022-01-04)
+
+### Fixed
+- Fallback match entries might lead to UnicodeDecodeError for large bytes sequence (PR #154)
+
+### Changed
+- Skipping the language-detection (CD) on ASCII (PR #155)
+
+## [2.0.9](https://github.com/Ousret/charset_normalizer/compare/2.0.8...2.0.9) (2021-12-03)
+
+### Changed
+- Moderating the logging impact (since 2.0.8) for specific environments (PR #147)
+
+### Fixed
+- Wrong logging level applied when setting kwarg `explain` to True (PR #146)
+
+## [2.0.8](https://github.com/Ousret/charset_normalizer/compare/2.0.7...2.0.8) (2021-11-24)
+### Changed
+- Improvement over Vietnamese detection (PR #126)
+- MD improvement on trailing data and long foreign (non-pure latin) data (PR #124)
+- Efficiency improvements in cd/alphabet_languages from [@adbar](https://github.com/adbar) (PR #122)
+- call sum() without an intermediary list following PEP 289 recommendations from [@adbar](https://github.com/adbar) (PR #129)
+- Code style as refactored by Sourcery-AI (PR #131)
+- Minor adjustment on the MD around european words (PR #133)
+- Remove and replace SRTs from assets / tests (PR #139)
+- Initialize the library logger with a `NullHandler` by default from [@nmaynes](https://github.com/nmaynes) (PR #135)
+- Setting kwarg `explain` to True will add provisionally (bounded to function lifespan) a specific stream handler (PR #135)
+
+### Fixed
+- Fix large (misleading) sequence giving UnicodeDecodeError (PR #137)
+- Avoid using too insignificant chunk (PR #137)
+
+### Added
+- Add and expose function `set_logging_handler` to configure a specific StreamHandler from [@nmaynes](https://github.com/nmaynes) (PR #135)
+- Add `CHANGELOG.md` entries, format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) (PR #141)
+
+## [2.0.7](https://github.com/Ousret/charset_normalizer/compare/2.0.6...2.0.7) (2021-10-11)
+### Added
+- Add support for Kazakh (Cyrillic) language detection (PR #109)
+
+### Changed
+- Further, improve inferring the language from a given single-byte code page (PR #112)
+- Vainly trying to leverage PEP263 when PEP3120 is not supported (PR #116)
+- Refactoring for potential performance improvements in loops from [@adbar](https://github.com/adbar) (PR #113)
+- Various detection improvement (MD+CD) (PR #117)
+
+### Removed
+- Remove redundant logging entry about detected language(s) (PR #115)
+
+### Fixed
+- Fix a minor inconsistency between Python 3.5 and other versions regarding language detection (PR #117 #102)
+
+## [2.0.6](https://github.com/Ousret/charset_normalizer/compare/2.0.5...2.0.6) (2021-09-18)
+### Fixed
+- Unforeseen regression with the loss of the backward-compatibility with some older minor of Python 3.5.x (PR #100)
+- Fix CLI crash when using --minimal output in certain cases (PR #103)
+
+### Changed
+- Minor improvement to the detection efficiency (less than 1%) (PR #106 #101)
+
+## [2.0.5](https://github.com/Ousret/charset_normalizer/compare/2.0.4...2.0.5) (2021-09-14)
+### Changed
+- The project now comply with: flake8, mypy, isort and black to ensure a better overall quality (PR #81)
+- The BC-support with v1.x was improved, the old staticmethods are restored (PR #82)
+- The Unicode detection is slightly improved (PR #93)
+- Add syntax sugar \_\_bool\_\_ for results CharsetMatches list-container (PR #91)
+
+### Removed
+- The project no longer raise warning on tiny content given for detection, will be simply logged as warning instead (PR #92)
+
+### Fixed
+- In some rare case, the chunks extractor could cut in the middle of a multi-byte character and could mislead the mess detection (PR #95)
+- Some rare 'space' characters could trip up the UnprintablePlugin/Mess detection (PR #96)
+- The MANIFEST.in was not exhaustive (PR #78)
+
+## [2.0.4](https://github.com/Ousret/charset_normalizer/compare/2.0.3...2.0.4) (2021-07-30)
+### Fixed
+- The CLI no longer raise an unexpected exception when no encoding has been found (PR #70)
+- Fix accessing the 'alphabets' property when the payload contains surrogate characters (PR #68)
+- The logger could mislead (explain=True) on detected languages and the impact of one MBCS match (PR #72)
+- Submatch factoring could be wrong in rare edge cases (PR #72)
+- Multiple files given to the CLI were ignored when publishing results to STDOUT. (After the first path) (PR #72)
+- Fix line endings from CRLF to LF for certain project files (PR #67)
+
+### Changed
+- Adjust the MD to lower the sensitivity, thus improving the global detection reliability (PR #69 #76)
+- Allow fallback on specified encoding if any (PR #71)
+
+## [2.0.3](https://github.com/Ousret/charset_normalizer/compare/2.0.2...2.0.3) (2021-07-16)
+### Changed
+- Part of the detection mechanism has been improved to be less sensitive, resulting in more accurate detection results. Especially ASCII. (PR #63)
+- According to the community wishes, the detection will fall back on ASCII or UTF-8 in a last-resort case. (PR #64)
+
+## [2.0.2](https://github.com/Ousret/charset_normalizer/compare/2.0.1...2.0.2) (2021-07-15)
+### Fixed
+- Empty/Too small JSON payload miss-detection fixed. Report from [@tseaver](https://github.com/tseaver) (PR #59)
+
+### Changed
+- Don't inject unicodedata2 into sys.modules from [@akx](https://github.com/akx) (PR #57)
+
+## [2.0.1](https://github.com/Ousret/charset_normalizer/compare/2.0.0...2.0.1) (2021-07-13)
+### Fixed
+- Make it work where there isn't a filesystem available, dropping assets frequencies.json. Report from [@sethmlarson](https://github.com/sethmlarson). (PR #55)
+- Using explain=False permanently disable the verbose output in the current runtime (PR #47)
+- One log entry (language target preemptive) was not show in logs when using explain=True (PR #47)
+- Fix undesired exception (ValueError) on getitem of instance CharsetMatches (PR #52)
+
+### Changed
+- Public function normalize default args values were not aligned with from_bytes (PR #53)
+
+### Added
+- You may now use charset aliases in cp_isolation and cp_exclusion arguments (PR #47)
+
+## [2.0.0](https://github.com/Ousret/charset_normalizer/compare/1.4.1...2.0.0) (2021-07-02)
+### Changed
+- 4x to 5 times faster than the previous 1.4.0 release. At least 2x faster than Chardet.
+- Accent has been made on UTF-8 detection, should perform rather instantaneous.
+- The backward compatibility with Chardet has been greatly improved. The legacy detect function returns an identical charset name whenever possible.
+- The detection mechanism has been slightly improved, now Turkish content is detected correctly (most of the time)
+- The program has been rewritten to ease the readability and maintainability. (+Using static typing)+
+- utf_7 detection has been reinstated.
+
+### Removed
+- This package no longer require anything when used with Python 3.5 (Dropped cached_property)
+- Removed support for these languages: Catalan, Esperanto, Kazakh, Baque, Volapük, Azeri, Galician, Nynorsk, Macedonian, and Serbocroatian.
+- The exception hook on UnicodeDecodeError has been removed.
+
+### Deprecated
+- Methods coherence_non_latin, w_counter, chaos_secondary_pass of the class CharsetMatch are now deprecated and scheduled for removal in v3.0
+
+### Fixed
+- The CLI output used the relative path of the file(s). Should be absolute.
+
+## [1.4.1](https://github.com/Ousret/charset_normalizer/compare/1.4.0...1.4.1) (2021-05-28)
+### Fixed
+- Logger configuration/usage no longer conflict with others (PR #44)
+
+## [1.4.0](https://github.com/Ousret/charset_normalizer/compare/1.3.9...1.4.0) (2021-05-21)
+### Removed
+- Using standard logging instead of using the package loguru.
+- Dropping nose test framework in favor of the maintained pytest.
+- Choose to not use dragonmapper package to help with gibberish Chinese/CJK text.
+- Require cached_property only for Python 3.5 due to constraint. Dropping for every other interpreter version.
+- Stop support for UTF-7 that does not contain a SIG.
+- Dropping PrettyTable, replaced with pure JSON output in CLI.
+
+### Fixed
+- BOM marker in a CharsetNormalizerMatch instance could be False in rare cases even if obviously present. Due to the sub-match factoring process.
+- Not searching properly for the BOM when trying utf32/16 parent codec.
+
+### Changed
+- Improving the package final size by compressing frequencies.json.
+- Huge improvement over the larges payload.
+
+### Added
+- CLI now produces JSON consumable output.
+- Return ASCII if given sequences fit. Given reasonable confidence.
+
+## [1.3.9](https://github.com/Ousret/charset_normalizer/compare/1.3.8...1.3.9) (2021-05-13)
+
+### Fixed
+- In some very rare cases, you may end up getting encode/decode errors due to a bad bytes payload (PR #40)
+
+## [1.3.8](https://github.com/Ousret/charset_normalizer/compare/1.3.7...1.3.8) (2021-05-12)
+
+### Fixed
+- Empty given payload for detection may cause an exception if trying to access the `alphabets` property. (PR #39)
+
+## [1.3.7](https://github.com/Ousret/charset_normalizer/compare/1.3.6...1.3.7) (2021-05-12)
+
+### Fixed
+- The legacy detect function should return UTF-8-SIG if sig is present in the payload. (PR #38)
+
+## [1.3.6](https://github.com/Ousret/charset_normalizer/compare/1.3.5...1.3.6) (2021-02-09)
+
+### Changed
+- Amend the previous release to allow prettytable 2.0 (PR #35)
+
+## [1.3.5](https://github.com/Ousret/charset_normalizer/compare/1.3.4...1.3.5) (2021-02-08)
+
+### Fixed
+- Fix error while using the package with a python pre-release interpreter (PR #33)
+
+### Changed
+- Dependencies refactoring, constraints revised.
+
+### Added
+- Add python 3.9 and 3.10 to the supported interpreters
+
+MIT License
+
+Copyright (c) 2025 TAHRI Ahmed R.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

venv/lib/python3.12/site-packages/charset_normalizer-3.4.9.dist-info/RECORD

@@ -0,0 +1,36 @@
+../../../bin/normalizer,sha256=g0IlkIjn1xmaIFNjQj1k40XlzyG1Hj51rQ1SX3MF8BY,277
+ada92cb5d92a588d1b93__mypyc.cpython-312-x86_64-linux-gnu.so,sha256=aIdLxZY-RSJ2C4KiLW5ye2ucy6X1_pw77SdPSlhVZyI,457584
+charset_normalizer-3.4.9.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+charset_normalizer-3.4.9.dist-info/METADATA,sha256=DdPeF2CbDbZL0dRkPFvQ3TW16zxb53-LF7wZDy9KKsA,41678
+charset_normalizer-3.4.9.dist-info/RECORD,,
+charset_normalizer-3.4.9.dist-info/WHEEL,sha256=kPfBHUCXEMd9_xazqE-bWrrpnGTuP83yeVdC3i0eh6U,190
+charset_normalizer-3.4.9.dist-info/entry_points.txt,sha256=ADSTKrkXZ3hhdOVFi6DcUEHQRS0xfxDIE_pEz4wLIXA,65
+charset_normalizer-3.4.9.dist-info/licenses/LICENSE,sha256=bQ1Bv-FwrGx9wkjJpj4lTQ-0WmDVCoJX0K-SxuJJuIc,1071
+charset_normalizer-3.4.9.dist-info/top_level.txt,sha256=y65Zf_GLs5FHscGHzcUTGAldXcp5mEVXbh8Mo0ZlmWs,47
+charset_normalizer/__init__.py,sha256=OKRxRv2Zhnqk00tqkN0c1BtJjm165fWXLydE52IKuHc,1590
+charset_normalizer/__main__.py,sha256=yzYxMR-IhKRHYwcSlavEv8oGdwxsR89mr2X09qXGdps,109
+charset_normalizer/__pycache__/__init__.cpython-312.pyc,,
+charset_normalizer/__pycache__/__main__.cpython-312.pyc,,
+charset_normalizer/__pycache__/api.cpython-312.pyc,,
+charset_normalizer/__pycache__/cd.cpython-312.pyc,,
+charset_normalizer/__pycache__/constant.cpython-312.pyc,,
+charset_normalizer/__pycache__/legacy.cpython-312.pyc,,
+charset_normalizer/__pycache__/md.cpython-312.pyc,,
+charset_normalizer/__pycache__/models.cpython-312.pyc,,
+charset_normalizer/__pycache__/utils.cpython-312.pyc,,
+charset_normalizer/__pycache__/version.cpython-312.pyc,,
+charset_normalizer/api.py,sha256=kXhFlZNMi6_p0YhbTeGTswoK_DZ6oeAdprPxE8F4yfM,42325
+charset_normalizer/cd.cpython-312-x86_64-linux-gnu.so,sha256=R9WQd3NirBV0quIUAT8Kr7kQ_h2EqUb94KGDOxFxxV4,16040
+charset_normalizer/cd.py,sha256=6dJOZvd0rrEEWvkx54kAEy9qAP_uIuiWMAi5wX8OZsY,15980
+charset_normalizer/cli/__init__.py,sha256=D8I86lFk2-py45JvqxniTirSj_sFyE6sjaY_0-G1shc,136
+charset_normalizer/cli/__main__.py,sha256=NPK3yYAkXXE7Uvs6IqijkgZzS6G6fguRFuKXzgpf8Uc,11949
+charset_normalizer/cli/__pycache__/__init__.cpython-312.pyc,,
+charset_normalizer/cli/__pycache__/__main__.cpython-312.pyc,,
+charset_normalizer/constant.py,sha256=vp9HvaompccS71BXPZk8lVahonkPbBpeVE3NzKZe2sk,44624
+charset_normalizer/legacy.py,sha256=bgkdEvubTCOPlMKOzuENXHMiarh36VaGbRvWSlIr1KA,2651
+charset_normalizer/md.cpython-312-x86_64-linux-gnu.so,sha256=1NCejiMAxx7khs9xwL4V2f-dahqGXknNz304xK9TJbY,16040
+charset_normalizer/md.py,sha256=bwD18o2xLkGxBkuM1HPnYULsLBzNVe09j727Tng2tJw,32641
+charset_normalizer/models.py,sha256=BAYguAENiSKBb7mf3DKzY3qgqjrjBeP0dySCmQSieXE,12830
+charset_normalizer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+charset_normalizer/utils.py,sha256=fMCjgJXzMFegyO-gX-NElZi1rmdF1y1xax2Y-V2eudo,13537
+charset_normalizer/version.py,sha256=FUQoaRCvGW_xwCoesgsGTwzekLTlCkAJr7diNpv-gPI,115

venv/lib/python3.12/site-packages/charset_normalizer-3.4.9.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_17_x86_64
+Tag: cp312-cp312-manylinux2014_x86_64
+Tag: cp312-cp312-manylinux_2_28_x86_64
+

venv/lib/python3.12/site-packages/charset_normalizer-3.4.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+normalizer = charset_normalizer.cli:cli_detect

venv/lib/python3.12/site-packages/charset_normalizer-3.4.9.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TAHRI Ahmed R.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

venv/lib/python3.12/site-packages/charset_normalizer-3.4.9.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+ada92cb5d92a588d1b93__mypyc
+charset_normalizer

venv/lib/python3.12/site-packages/charset_normalizer/__init__.py

@@ -0,0 +1,48 @@
+"""
+Charset-Normalizer
+~~~~~~~~~~~~~~
+The Real First Universal Charset Detector.
+A library that helps you read text from an unknown charset encoding.
+Motivated by chardet, This package is trying to resolve the issue by taking a new approach.
+All IANA character set names for which the Python core library provides codecs are supported.
+
+Basic usage:
+   >>> from charset_normalizer import from_bytes
+   >>> results = from_bytes('Bсеки човек има право на образование. Oбразованието!'.encode('utf_8'))
+   >>> best_guess = results.best()
+   >>> str(best_guess)
+   'Bсеки човек има право на образование. Oбразованието!'
+
+Others methods and usages are available - see the full documentation
+at <https://github.com/Ousret/charset_normalizer>.
+:copyright: (c) 2021 by Ahmed TAHRI
+:license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from .api import from_bytes, from_fp, from_path, is_binary
+from .legacy import detect
+from .models import CharsetMatch, CharsetMatches
+from .utils import set_logging_handler
+from .version import VERSION, __version__
+
+__all__ = (
+    "from_fp",
+    "from_path",
+    "from_bytes",
+    "is_binary",
+    "detect",
+    "CharsetMatch",
+    "CharsetMatches",
+    "__version__",
+    "VERSION",
+    "set_logging_handler",
+)
+
+# Attach a NullHandler to the top level logger by default
+# https://docs.python.org/3.3/howto/logging.html#configuring-logging-for-a-library
+
+logging.getLogger("charset_normalizer").addHandler(logging.NullHandler())

venv/lib/python3.12/site-packages/charset_normalizer/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .cli import cli_detect
+
+if __name__ == "__main__":
+    cli_detect()