Questo articolo rappresenta sia una guida alla scrittura di template Jinja con Home Assistant che un riferimento rapido da usare durante la scrittura dei tuoi template.
Questo articolo non intende sostituire le documentazioni ufficiali (fonte primaria e insostituibile) ma mira a offrire una raccolta di esempi pratici e approfondimenti in un’unica pagina semplice da fruire, in lingua italiana. L’obiettivo è rendere la documentazione di Jinja per Home Assistant più accessibile e leggibile, considerando che le pagine ufficiali sono scritte in modo poco intuitivo, senza esempi o con esempi non inerenti al mondo di Home Assistant. Inoltre la documentazione non è unica ma così suddivisa, rendendone ulteriormente complessa la comprensione e ricerca:
È opportuno sottolineare che le informazioni riguardanti le estensioni di Home Assistant sono aggiornate alla versione 2024.4.
Si noti infine che nel presente articolo non sono presenti il 100% dei concetti dei template Jinja, ma i più importanti e significativi considerandone l’utilizzo nella realtà di Home Assistant, con un esempio per ogni concetto a chiarirne concretamente il modo di utilizzo pratico.
Ma prima di iniziare: cos’è un template Jinja in Home Assistant? (spesso chiamato anche Jinja2) E’ un insieme di istruzioni per sostituire ad un valore statico un valore calcolato da uno script dinamico. Puoi immaginarlo come un piccolo pezzo di codice sorgente che determina un risultato che sarà calcolato al momento dell’esecuzione e il cui risultato sarà quindi usato laddove il template è stato posto. Un esempio è meglio di mille parole, per capire il concetto: immagina di voler far pronunciare un testo dinamico ad un dispositivo multimediale, ad esempio usando multinotify. Al posto di un messaggio statico come message: "Ciao Mario, come stai?" puoi scrivere un semplice template message: "Ciao {{nome_utente}}, come stai alle {{ now().strftime('%H:%M') }}?". All’esecuzione verrà interpretato e generato un messaggio come “Ciao Mario, come stai alle 16:35?” Non ti soffermare sui dettagli, era solo per capire il principio di funzionamento.
Questo era un esempio molto semplice ma nei template ci possono essere condizioni, cicli, analisi di liste e dizionari, per citarne qualcuna. Possiamo quindi creare delle logiche molto complesse con una discreta semplicità (una volta imparata la sintassi 🙂 ).
I template possono essere utilizzati in svariati contesti riguardanti la configurazione di Home Assistant: nelle automazioni, script, sensori ed altre componenti del sistema per manipolare dati, creare espressioni condizionali o generare valori dinamici.
Per completare questa operazione, è necessario diventare familiari con la scheda “Modelli” nell’ambiente degli strumenti per sviluppatori. Questa scheda consente di testare e valutare i modelli direttamente dall’interfaccia utente. Questo strumento è particolarmente utile per sviluppare e risolvere problemi nei modelli senza doverli collaudare direttamente in automazioni, script o sensori, riducendo parecchio la complessità di debug.
Delimitatori
I delimitatori sono segni o simboli che vengono utilizzati per racchiudere e identificare l’inizio e la fine di un blocco di codice all’interno di un template. Questi delimitatori servono a indicare al motore di templating di Jinja2 quali parti del testo devono essere interpretate per esprimere variabili, creare istruzioni condizionali, cicli, per inserire commenti o stampare output.
{{ ... }}: Utilizzati per racchiudere espressioni. Ad esempio, {{ 'HomeAssistant' }}
{#...#} Utilizzati per commentare il codice. Il testo compreso tra questi delimitatori non verrà interpretato.
{% ... %}}: Utilizzati per racchiudere istruzioni, come cicli, variabili o condizioni. Ad esempio, {% if condizione %} ... {% endif %} indica un blocco condizionale.
⬇️ Il carattere - vicino all’indentazione viene utilizzato per gestire lo spazio in eccesso o in meno che potrebbe essere generato durante il rendering del template.
Nel primo esempio, i numeri vengono stampati con uno spazio bianco sia prima che dopo ciascuno di essi. mentre nel secondo esempio li spazi bianchi iniziali e finali attorno al valore di i vengono rimossi.
{% for i in range(5) %}
{{ i }}
{% endfor %}
{# otuput:
0
1
2
3
4
#}
{%- for i in range(5) %}
{{- i -}}
{% endfor %}
{# outpu: 01234 #}
Indentazione
In Home Assistant, puoi definire i template sia come stringhe multilinea che come stringhe su una singola linea. Tuttavia, è importante prestare attenzione alla formattazione e all’indentazione quando si lavora con YAML.
Nel caso di stringhe multilinea, il carattere > in YAML indica di unire le linee separatamente da uno spazio, preservando comunque gli a capo.
Quando si scrive un template su una singola linea, è necessario racchiudere il template tra virgolette doppie " o singole '. Questo assicura che il template venga interpretato correttamente all’interno della struttura YAML, evitando problemi di parsing.
message: >
{{ 'Questo è un esempio di
template su più linee in YAML.' }}
message: "{{ 'Questo è un esempio di template su una singola linea.' }}"
message: '{{ "Questo è un esempio di template su una singola linea." }}'
Variabili
Un’altra caratteristica fondamentale sono le variabili. A volte è necessario richiamare alcuni valori nel template. Per fare ciò, puoi creare una variabile, che memorizzerà il valore per te. Una variabile ha sempre un nome, con il quale può essere chiamata durante il rendering, e ha anche un tipo. Prima di poter utilizzare la variabile, è necessario inizializzarla. Puoi farlo usando il comando '{% set nome_variabile = ... %}'
{% set stato_allarme = states('alarm_control_panel.home_alarm')%}
{{ stato_allarme }} {# output verrà restituito lo stato dell'allarme #}
Quella dell’esempio sono le variabili globali più comunemente usate ed accessibile in tutto il template, ma è possibile avere anche variabile locali anche se poco utilizzate. Questa è definita all’interno di un blocco specifico e sarà limitata a quel blocco.
{% set var_globale = 'Sono globale' %} {# Definizione di una variabile globale #}
{% block my_block %}
{% set var_locale = 'Sono locale' %} {# Definizione di una variabile locale all'interno del blocco #}
{{ var_locale }}
{% endblock %} {# Il blocco my_block termina qui #}
{{ var_globale }} {# Stampa della variabile globale che può essere usata sia dentro che fuori dal blocco #}
Tipi di risultati
In un template, il risultato di un’espressione può essere di vari tipi di dati, come stringhe, numeri, booleani, liste, dizionari o variabili non definite. Questo dipende dalle operazioni specifiche eseguite nell’espressione. La flessibilità di Jinja2 consente di lavorare con una varietà di tipi di dati nei template.
Stringhe
Il termine ‘stringa’ si riferisce a una sequenza di caratteri, come parole e frasi, racchiuse tra virgolette singole '' o doppie "". Le stringhe sono impiegate per rappresentare testo e possono essere manipolate in vari modi all’interno del template. Quando si utilizzano virgolette per racchiudere un numero, questo viene automaticamente convertito in una stringa.
È possibile concatenare più stringhe utilizzando l’operatore ~ . Quando si utilizza ~ con un numero e una stringa, Jinja2 converte automaticamente il numero in una stringa prima di effettuare la concatenazione.
{{ 'HomeAssistante' }} o {{ " HomeAssistant" }}
{{ "4" }} {# type stringa #} {{ 4 }} {# type numero #}
{{ 'versione' ~ 2024 }} {# versione 2024 #}
Numeri
I numeri sono di due tipi principali: interi (int) e decimali (float). Il tipo esatto dipende dal modo in cui il numero è scritto nel template. Puoi utilizzare questi numeri in operazioni matematiche all’interno dei tuoi template.
{{ 50 }} {# int #}
{{ 55.3 }} {# float #}
Liste
Pensa a una lista come a un registro dettagliato di cose che hai, mettendole in fila in un ordine specifico. È come se stessi organizzando i tuoi oggetti preferiti in una fila, dove ogni elemento ha un posto ben definito. Puoi mettere numeri, parole o qualsiasi cosa desideri in questa fila. Basta scrivere gli oggetti separati da virgole e racchiuderli tra parentesi quadre, come se stessi creando un elenco numerato. Quindi, quando dici che le liste sono ordinate, significa che c’è una sequenza specifica in cui gli elementi sono disposti, proprio come quando numeri le tue cose preferite in un elenco dettagliato.
Vediamo un esempio, immagina che la variabile my_list sia come una scatola magica che contiene gli elementi che hai inserito: 'elemento1', 'elemento2', 'elemento3' e il numero 55. Quando mostri my_list, ottieni esattamente quella sequenza.
Ora, parlando di HomeAssistant, stiamo creando una lista chiamata my_light che contiene gli identificatori di tutte le entità light. È come fare un elenco di tutte le luci nella tua casa. Quindi, quando mostri my_light, ottieni l’elenco di tutte le entità light presenti nel sistema HomeAssistant.
È possibile applicare diversi filtri a una lista in modo da modificarne o manipolarne gli elementi.
Dettaglio
⬇️ Con gli indici, puoi accedere a elementi specifici nella lista. Ricorda che gli indici iniziano da 0.
Nell’esempio, my_light[0] restituisce il primo elemento della lista, che è ‘light.philips55’, e my_light[2] restituisce il terzo elemento, che è 'light.luce_corridoio'.
⬇️ Con range, puoi visualizzare solo una parte specifica della lista.
Nell’esempio, my_list[0:2] indica di mostrare gli elementi dall’indice 0 al 2 (escluso). Quindi, ottieni ['elemento1', 'elemento2'] come output, che rappresenta i primi due elementi della lista.
Se vuoi includere tutti gli elementi dall’inizio fino a un certo punto o da un certo punto fino alla fine, puoi lasciare vuoto il campo non desiderato nel range. Ad esempio, my_list[2:] indica di mostrare gli elementi dall’indice 2 fino alla fine della lista, ottenendo ['elemento3', 55]. Mentre my_list[:2] indica di mostrare gli elementi dall’inizio fino all’indice 2 (escluso), ottenendo ['elemento1', 'elemento2']
Nell’esempio, my_list + new_list unisce le due liste, aggiungendo gli elementi di new_list alla fine di my_list. Quindi, otterrai una nuova lista combinata con tutti gli elementi: ["elemento1", "elemento2", "elemento3", 55, 'new_elemento1', 'new_elemento2'].
⬇️ Puoi manipolare la lista sostituendo un elemento specifico.
Nell’esempio, my_list[:2] rappresenta gli elementi fino all’indice 2 (escluso), quindi ['elemento1', 'elemento2']. Aggiungendo [new_element], stai inserendo il nuovo elemento desiderato. Infine, my_list[3:] rappresenta gli elementi dall’indice 3 in poi, quindi [55]. Unendo tutti questi pezzi, ottieni la lista modificata: ["elemento1", "elemento2", "nuovo_elemento", 55].
⬇️ Puoi conoscere il numero di elementi nella lista utilizzando |count o |length. Entrambi forniscono lo stesso risultato, che è il numero totale di elementi nella lista.
⬇️ Puoi verificare se un elemento è presente nella lista utilizzando l’operatore in.
Nell’esempio, 'elemento1' in my_list restituisce True perché ‘elemento1’ è presente nella lista. D’altra parte, 'elemento_none' in my_list restituisce False poiché 'elemento_none' non è presente nella lista.
{% set my_list = ['elemento1', 'elemento2', 'elemento3', 55] %}
{{ 'elemento1' in my_list }} {# output True #}
{{ 'elemento_none' in my_list }} {# output False #}
{% set my_light = states.light | map(attribute='entity_id') |list %}
{{ 'light.philips55' in my_light}} {# output True #}
{{ 'light.inventata' in my_light }} {# output False #}
⬇️ Puoi contare quante volte un elemento è presente nella lista usando il metodo count.
Nell’esempio, my_list.count('elemento1') restituisce 1 perché 'elemento1' è presente una volta nella lista. D’altra parte, my_list.count('elemento_none') restituisce 0 perché 'elemento_none' non è presente nella lista.
⬇️ Puoi eseguire operazioni matematiche sugli elementi di una lista, ma è importante assicurarsi che gli elementi siano di tipo numerico.
Nell’esempio, my_list[3] + 22 restituisce 77 perché my_list[3] è un numero, mentre my_list[1] + 22 genera un errore di tipo (TypeError) perché my_list[1] è una stringa, e non può concatenare direttamente una stringa con un numero.
{% set my_list = ['elemento1', 'elemento2', 'elemento3', 55] %}
{{ my_list[3] + 22 }} {# output 77 #}
{{ my_list[1] + 22 }} {# output ERORE TypeError: can only concatenate str (not "int") to str #}
{% set my_light = states.sensor | map(attribute='state')| select('is_number')| map('float') |list %}
{{ my_light[0] + 5}} {# output [valore primo sensore + 5] #}
⬇️ Puoi utilizzare il filtro sum per ottenere la somma di tutti gli elementi di una lista, ma è importante assicurarsi che gli elementi siano di tipo numerico.
Nell’esempio, my_list_num|sum restituisce la somma di tutti i numeri nella lista, che è 104. È come se stessi facendo la somma dei valori numerici nella tua sequenza di numeri.
{% set my_list_num = [1,5,7,3,56,32] %}
{{ my_list_num|sum }} {# output 104 #}
{% set my_light = states.sensor | map(attribute='state') | select('is_number') | map('float') |list %}
{{ my_light|sum}} {# output somma di tutti li stati numerici dei sensori #}
⬇️ Puoi unire gli elementi di una lista in modo più leggibile utilizzando il filtro join.
Nell’esempio, my_list|join(', ') restituisce una stringa in cui gli elementi della lista sono separati da una virgola seguita da uno spazio, rendendo l’output più leggibile.
⬇️ Puoi rimuovere gli elementi da una lista utilizzando il filtro reject o la funzione .pop().
Nell’esempio, my_list|reject('eq','elemento2') rimuove gli elementi che sono uguali a 'elemento2' dalla lista, restituendo ['elemento1', 'elemento3', 55].
{% set my_list = ['elemento1', 'elemento2','elemento3', 55] %}
{{ my_list|reject('eq', 'elemento2') | list}} {# output elemento1, elemento3, 55 #}
{% set my_light = states.switch | map(attribute='state') | unique | list %}
{{ my_light | reject('eq', 'unavailable') | list}} {# output: stati che hanno li switch escluso unavailable #}
Nell’esempio fornito, my_list.pop(0) viene utilizzato per rimuovere l’elemento in posizione 0 dall’elenco my_list. Questo metodo restituisce l’elemento rimosso, che nel caso dell’elenco my_list è ‘elemento1’. Successivamente, my_list è modificato e ora contiene solo gli elementi ‘elemento2’, ‘elemento3’ e 55.
Nell’esempio fornito, my_light.pop(0) viene utilizzato per rimuovere l’elemento in posizione 0 dall’elenco my_light. Successivamente, my_light è modificato e ora contiene solo gli elementi ‘elemento2’, ‘elemento3’ e 55.
⬇️ Puoi selezionare solo gli elementi che soddisfano una condizione specifica utilizzando il filtro select.
Nell’esempio, my_list|select('eq','elemento2') restituisce una nuova lista contenente solo gli elementi che sono uguali a 'elemento2', quindi ['elemento2'].
{% set my_list = ['elemento1', 'elemento2','elemento3', 55] %}
{{ my_list|select('eq','elemento2') |list}} {# output ['elemento2'] #}
{% set my_light = states.switch| map(attribute='state')|list %}
{{ my_light|select('eq','unavailable')|list }} {# output lista di tanti unavailable quanti sono li switch in quello stato #}
⬇️ Puoi ordinare una lista, che può essere composta sia da elementi stringa che numerici, utilizzando il filtro sort.
Nell’esempio, my_list|sort ordina la lista in ordine ascendente. Per le stringhe, l’ordinamento è basato sull’ordine alfabetico, mentre per i numeri, è basato sull’ordine numerico.
{% set my_list = ['elemento3', 'elemento1','elemento2'] %}
{{ my_list|sort}} {# output ['elemento1', 'elemento2', 'elemento3'] #}
{% set my_list = [55, 2, 24,33] %}
{{ my_list|sort}} {# output [2,24,33,55] #}
{% set my_light = states.switch| map(attribute='name')|list %}
{{ my_light|sort}} {# output tutti i name degli switch in ordine alfabetico #}
⬇️ Puoi sapere un elemento specifico che indice occupa all’interno di una lista, utilizzando la funzione .index(value).
I dizionari sono strutture dati che contengono coppie chiave-valore. Un dizionario è una collezione di elementi, dove ogni elemento è composto da una chiave unica e il valore associato a quella chiave. In termini più semplici è un modo per organizzare informazioni. Puoi immaginarlo come una lista di cose, ma ogni cosa ha un nome speciale chiamato “chiave”. Ogni “chiave” ha un “valore” associato ad essa. L’accesso al valore di una chiave in un dizionario può essere eseguito utilizzando la sintassi dict['key'] o dict.key: consente di ottenere il valore associato a quella chiave all’interno del dizionario.
{% set my_dict = { 'nome' : 'Home Assistant' , 'versione' : '2024.1' , 'componenti' : ['File Editor', 'Samba', 'Zigbee2MQTT'] } %}
{{'Programma ' ~ my_dict['nome'] }} {# Programma Home Assistant #}
{{'In uso: ' ~ my_dict.versione }} {# In uso: 2024.1 #}
Componenti aggiuntivi:
{%- for voto in my_dict['componenti'] %} {# Iterazione attraverso una lista all'interno del dizionario #}
{{- voto }}
{%- endfor %}
{# Componenti aggiuntivi: File Editor Samba Zigbee2MQTT #}
È possibile applicare diversi filtri a un dizionario in modo da modificarne o manipolarne gli elementi.
Dettaglio
⬇️ .keys(): viene utilizzato per ottenere un elenco delle chiavi di un dizionario.
⬇️ .get(key, default) viene utilizzato per ottenere il valore associato a una chiave in un dizionario. L’uso del metodo get() è utile perché consente di specificare un valore predefinito da restituire nel caso in cui la chiave non sia presente nel dizionario.
{% set my_dict = { 'nome' : 'Home Assistant' , 'versione' : '2024.1' , 'componenti' : ['File Editor', 'Samba', 'Zigbee2MQTT'] } %}
{{ 'Chiave nome: ' ~ my_dict.get('nome', 'Valore non presente') }}
{{ 'Altra chiave: ' ~ my_dict.get('altro', 'Valore non presente') }}
{#
Chiave nome: Home Assistant
Altra chiave: Valore non presente
#}
⬇️ Se un dizionario contiene un altro dizionario come valore associato a una chiave, puoi accedere ai valori all’interno del dizionario interno in modo concatenato
Un booleano è un tipo di dato che può assumere solo due valori: vero (True) o falso (False). Questo tipo di dato è comunemente utilizzato per rappresentare condizioni o verità.
{{ 5 == 4 }} {# False #}
{{ 5 == 5 }} {# True #}
Tuple
Una tupla è una struttura dati che rappresenta una sequenza ordinata e immutabile di elementi. A differenza delle liste, le tuple sono immutabili, il che significa che una volta create non è possibile modificarne gli elementi. Le tuple sono definite utilizzando parentesi tonde () e gli elementi sono separati da virgole.
Jinja supporta nativamente la conversione di un iterabile in una lista, ma non supporta la conversione in un tuple. Per aiutarti nell’uso di questi tipi, puoi utilizzare la funzione tuple(x):
Un set è una collezione di elementi che non può contenere duplicati e non segue un ordine specifico degli elementi. È definito utilizzando parentesi graffe {} e contiene elementi separati da virgole.
Jinja supporta nativamente la conversione di un iterabile in una lista, ma non supporta la conversione in un set. Per aiutarti nell’uso di questi tipi, puoi utilizzare la funzione set(x):
Le espressioni più basilari in Jinja sono le espressioni matematiche. Spesso devi eseguire operazioni matematiche sui tuoi dati e Jinja2 contiene le operazioni elementari che potresti dover eseguire. Si consiglia di convertire i numeri in float o int utilizzando il rispettivo filtro quando si confrontano i numeri
Dettaglio
⬇️ +: è possibile sommare valori.
{{ 5 + 2.1 }} {# somma di due numeri = '7.1' #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var + 5 }} {# aggiunto un delta di 5 alla temperatura sala #}
⬇️ -: è possibile sottrarre valori.
{{ 5 - 2.1 }} {# sottrazione di due numeri = 2.9 #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var - 5 }} {# sottratto un delta di 5 alla temperatura sala #}
⬇️ /: è possibile dividere valori.
{{ 5 / 2 }} {# divisione di due numeri = 2.5 #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var / 5 }} {# divisione dello stato di un sensore #}
⬇️ *: è possibile moltiplicare valori.
{{ 5 * 2 }} {# moltiplicazione di due numeri = 10 #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var * 5 }} {# moltiplicazione dello stato di un sensore #}
⬇️ //: è possibile ottenere il risultato intero della divisione arrotondato per difetto.
{{ 5 * 2 }} {# mol{{ 5 // 2 }} {# numero intero della divisione di due numeri = 2 #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var // 5 }} {# numero intero della divisione dello stato di un sensore #}tiplicazione di due numeri = 10 #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var * 5 }} {# moltiplicazione dello stato di un sensore #}
⬇️ %: è possibile calcolare il resto della divisione.
{{ 60 % 55 }} {# resto della divisione di due numeri = 5 #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var % 5 }} {# resto della divisione dello stato di un sensore #}
⬇️ **: è possibile calcolare la potenza.
{{ 5 ** 2 }} {# 25 #}
{% set var = states('sensor.temperature_sala_temperature')|int(0) %}
{{ var ** 5 }} {# calcola potenza di un sensore #}
Le operazioni matematiche possono essere concatenate, quindi possiamo eseguire una sequenza di operazioni su variabili o valori costanti all’interno dei template. Questa concatenazione consente di eseguire calcoli più complessi, combinando operazioni di somma, sottrazione, moltiplicazione, divisione e altro ancora.
{% set variabile1 = 10 %}
{% set variabile2 = 5 %}
{{ variabile1 + variabile2 * 2 }}
Operatori di confronto
Gli operatori di confronto sono utilizzati per confrontare valori o espressioni e restituire un valore booleano che indica se la condizione è vera o falsa
Dettaglio
⬇️ ==Uguaglianza: Questo operatore verifica se due oggetti sono uguali. Restituisce True se sono uguali, altrimenti restituisce False.
{% set var = 'Ciao' %}
{{ 5 == 6 }} {# false #}
{{ 5 == 5 }} {# true #}
{{ 'ciao' == var }} {# false #}
{{ 'Ciao' == var }} {# true #}
⬇️ !=Disuguaglianza: Questo operatore verifica se due oggetti sono diversi. Restituisce True se sono diversi, altrimenti restituisce False .
{% set var = 'Ciao' %}
{{ 5 != 6 }} {# true #}
{{ 5 != 5 }} {# false #}
{{ 'ciao' != var }} {# true #}
{{ 'Ciao' != var }} {# false #}
⬇️ >Maggiore: Restituisce True se il lato sinistro è maggiore del lato destro.
{% set var = 'Ciao' %}
{{ 5 > 6 }} {# false #}
{{ 5 > 5 }} {# false #}
{{ 'ciao' > var }} {# true #}
{{ 'Ciao' > var }} {# false #}
⬇️ >=Maggiore o Uguale: Restituisce True se il lato sinistro è maggiore o uguale al lato destro.
{% set var = 'Ciao' %}
{{ 5 >= 6 }} {# false #}
{{ 5 >= 5 }} {# true #}
{{ 'ciao' >= var }} {# true #}
{{ 'Ciao' >= var }} {# true #}
⬇️ <Minore: Restituisce True se il lato sinistro è minore del lato destro.
{% set var = 'Ciao' %}
{{ 5 < 6 }} {# true #}
{{ 5 < 5 }} {# false #}
{{ 'ciao' < var }} {# false #}
{{ 'Ciao' < var }} {# false #}
⬇️ <=Minore o Uguale: Restituisce True se il lato sinistro è minore o uguale al lato destro.
{% set var = 'Ciao' %}
{{ 5 <= 6 }} {# true #}
{{ 5 <= 5 }} {# true #}
{{ 'ciao' <= var }} {# false #}
{{ 'Ciao' <= var }} {# true #}
Espressioni logiche
Le espressioni logiche sono come “domande” attraverso le quali chiediamo al sistema di valutare la veridicità di una determinata affermazione. La risposta finale a questa “domanda” è sempre booleana, ossia True (vero) o False (falso).
Dettaglio
⬇️ and: Restituisce True se sia l’operando sinistro che quello destro sono valutati come True. In altre parole, se entrambe le condizioni sono soddisfatte, l’espressione complessiva restituisce True; altrimenti, restituirà False.
{% set condizione_true = 5 == 5 %} {# true #}
{% set cond_num_false = 5 == 6 %} {# false #}
{{ condizione_true and cond_num_false }} {# solo una condizione è true: false #}
{{ condizione_true and condizione_true }} {# entrambe le condizioni sono true: true #}
{{ cond_num_false and cond_num_false }} {# entrambe le condizioni sono false: false #}
⬇️ or: restituisce True se almeno uno tra l’operando sinistro e quello destro è valutato come True. In altre parole, se almeno una delle condizioni è soddisfatta, l’espressione complessiva restituirà True; restituirà False solo se entrambi gli operandi sono valutati come False.
{% set condizione_true = 5 == 5 %} {# true #}
{% set cond_num_false = 5 == 6 %} {# false #}
{{ condizione_true or cond_num_false }} {# un condizione è triue: true #}
{{ condizione_true or condizione_true }} {# entrambe le condizioni sono true: true #}
{{ cond_num_false or cond_num_false }} {# entrambe le condizioni sono false: false #}
⬇️ not: viene utilizzato per negare un’affermazione. In altre parole, restituisce True se l’affermazione è falsa, e False se l’affermazione è vera.
{% set condizione_true = 5 == 5 %} {# true #}
{% set cond_num_false = 5 == 6 %} {# false #}
{{ not condizione_true}} {# false #}
{{ not cond_num_false}} {# true #}
⬇️ in: utilizzato per verificare se un valore è contenuto in una sequenza. La sequenza può essere una lista, una stringa, un dizionario o un’altra struttura dati iterabile. L’operatore restituisce True se il valore è presente nella sequenza, altrimenti restituirà False.
{% set my_list = ['elemento1','elemento2','elemento3'] %}
{{ 'elemento1' in my_list }} {# elemento presente nella lista: True #}
{{ 'elemento4' in my_list }} {# elemento non presente nella lista: False #}
{% set my_dict = { 'chiave1' : 'valore1', 'chiave2' : 'valore2'} %}
{{ 'chiave1' in my_dict }} {# key presente nel dict: True #}
{{ 'chiave3' in my_dict }} {# key non presente nel dict: True #}
⬇️ is: viene utilizzato per applicare test specifici a una variabile. Consente di eseguire un test specificato dal lato destro dell’espressione su una variabile situata sul lato sinistro.
is divisibleby: viene utilizzato per verificare se il primo valore è divisibile per il secondo valore(solo numeri).
{{ 4 is divisibleby 2 }} {# true #}
{{ 5 is divisibleby 3 }} {# false #}
is defined: viene utilizzato per verificare se una variabile è stata definita nel contesto del template.
{% set variabile = 'Variabile' %}
{{ variabile is defined }} {# true #}
{{ variabile_inventata is defined }} {# false #}
{{ 5 is defined }} {# true #}
is undefined: viene utilizzato per verificare se una variabile non è stata definita nel contesto del template.
{% set variabile = 'Variabile' %}
{{ variabile is undefined }} {# false #}
{{ variabile_inventata is undefined }} {# true #}
{{ 5 is undefined }} {# false #}
is eq: è equivalente all’operatore == e restituisce True se la variabile è uguale al secondo valore, altrimenti restituisce False.
{% set var = 'Ciao' %}
{{ 5 is eq 6 }} {# false #}
{{ 5 is eq 5 }} {# true #}
{{ 'ciao' is eq var }} {# false #}
{{ 'Ciao' is eq var }} {# true #}
is ge: è equivalente all’operatore >= e restituisce True se la variabile è maggiore o uguale al secondo valore, altrimenti restituisce False.
{% set var = 'Ciao' %}
{{ 5 is ge 6 }} {# false #}
{{ 5 is ge 5 }} {# true #}
{{ 'ciao' is ge var }} {# true #}
{{ 'Ciao' is ge var }} {# true #}
is le: è equivalente all’operatore <= e restituisce True se la variabile è minore o uguale al secondo valore, altrimenti restituisce False.
{% set var = 'Ciao' %}
{{ 5 is le 6 }} {# true #}
{{ 5 is le 5 }} {# true #}
{{ 'ciao' is le var }} {# false #}
{{ 'Ciao' is le var }} {# true #}
is gt: è equivalente all’operatore > e restituisce True se la variabile è maggiore al secondo valore, altrimenti restituisce False.
{% set var = 'Ciao' %}
{{ 5 is gt 6 }} {# false #}
{{ 5 is gt 5 }} {# false #}
{{ 'ciao' is gt var }} {# true #}
{{ 'Ciao' is gt var }} {# false #}
is lt: è equivalente all’operatore < e restituisce True se la variabile è minore al secondo valore, altrimenti restituisce False.
{% set var = 'Ciao' %}
{{ 5 is lt 6 }} {# true #}
{{ 5 is lt 5 }} {# false #}
{{ 'ciao' is lt var }} {# false #}
{{ 'Ciao' is lt var }} {# false #}
is ne: è equivalente all’operatore != e restituisce True se la variabile non è uguale al secondo valore, altrimenti restituisce False.
{% set var = 'Ciao' %}
{{ 5 is ne 6 }} {# true #}
{{ 5 is ne 5 }} {# false #}
{{ 'ciao' is ne var }} {# true #}
{{ 'Ciao' is ne var }} {# false #}
is none: restituisce True se la variabile è None, altrimenti restituisce False.
{% set variabile = 'Variabile' %}
{{ variabile is none }} {# false #}
{{ variabile_inventata is none }} {# false #}
{{ none is none }} {# true #}
is number: restituisce True se la variabile è di tipo numerico, altrimenti restituisce False.
{{ 'Variaile' is number }} {# false #}
{{ 6 is number }} {# true #}
is even: restituisce True se la variabile è un numero pari, altrimenti restituisce False (solo numeri).
{{ 3 is even }} {# false #}
{{ 4 is even }} {# true #}
is odd: restituisce True se la variabile è un numero dispari, altrimenti restituisce False.
{{ 3 is odd }} {# true #}
{{ 4 is odd }} {# false #}
is sequence: restituisce True se la variabile è una sequenza, altrimenti restituisce False.
{{ 3 is sequence }} {# false #}
{{ 'HOMEASSISTI' is sequence }} {# true (viene considerato ogni singolo carattere) #}
{{ ['A','B'] is sequence }} {# true #}
{{ { 'nome' : 'marco', 'città': 'Roma' } is sequence }} {# true #}
is string: restituisce True se la variabile è una stringa, altrimenti restituisce False.
{{ 3 is string }} {# false #}
{{ 'HomeAssistant' is string }} {# true #}
{{ ['a','b'] is string }} {# false #}
{{ { 'nome' : 'marco', 'città': 'roma' } is string }} {# false #}
is list: restituisce True se la variabile è una lista, altrimenti restituisce False.
{{ ['elemento1', 12, 'elemento3' ] is list }} {# True #}
{{ 'elemtento1' is list }} {# False #}
is tuple: restituisce True se la variabile è una tupla, altrimenti restituisce False.
{{ [1, 2] is tuple }} {# False #}
{{ (1, 2) is tuple }} {# True #}
is datetime: restituisce True se la variabile è un ogetto datetime, altrimenti restituisce False.
{{ '26, 12, 2024' is datetime }} {# False #}
{{ states['light.luce_studio'].last_changed is datetime }} {# True #}
is lower: restituisce True se la variabile è scritta in minuscolo, altrimenti restituisce False.
{{ 3 is lower }} {# false #}
{{ 'HomeAssistant' is lower }} {# false #}
{{ 'homeassistant' is lower }} {# true #}
{{ ['a','b'] is lower }} {# true #}
{{ ['a','B'] is lower }} {# false #}
{{ { 'nome' : 'marco', 'città': 'Roma' } is lower }} {# false #}
{{ { 'nome' : 'marco', 'città': 'roma' } is lower }} {# true #}
is upper: restituisce True se la variabile è scritta in maiuscolo, altrimenti restituisce False.
{{ 3 is upper }} {# false #}
{{ 'homeassistant' is upper }} {# false #}
{{ 'HOMEASSISTI' is upper }} {# true #}
{{ ['A','B'] is upper }} {# true #}
{{ ['a','B'] is upper }} {# false #}
{{ { 'nome' : 'marco', 'città': 'Roma' } is upper }} {# false #}
{{ { 'NOME' : 'MARCO', 'CITTA': 'ROMA' } is upper }} {# true #}
is iterable: verifica se un oggetto può essere iterato o attraversato elemento per elemento. Un oggetto iterable può essere utilizzato in un ciclo.
{{ 3 is iterable }} {# false #}
{{ 'HOMEASSISTI' is iterable }} {# true (viene considerato ogni singolo carattere) #}
{{ ['A','B'] is iterable }} {# true #}
{{ { 'nome' : 'marco', 'città': 'Roma' } is iterable }} {# true #}
is mapping: verifica se un oggetto è un mapping, come un dizionario.
{% set my_dict = {'chiave1': 'valore1', 'chiave2': 'valore2'} %}
{{ my_dict is mapping }} {# true #}
{{ 'testo' is mapping }} {# false #}
is boolean: restituisce True se la variabile è un boolean, altrimenti restituisce False.
{{ 'testo' is boolean }} {# false #}
{{ ( 5 == 5 ) is boolean }} {# true #}
{{ 5 is boolean }} {# false #}
is match(find, ignorecase=False): verifica se la stringa inizia con find. Quando ignorecase è impostato su True, la ricerca delle corrispondenze non terrà conto delle differenze tra maiuscole e minuscole.
{% set test_string = "Ciao, testiamo la funzione" %}
{{ test_string is match('Ciao') }} {# True #}
{{ test_string is match('ciao') }} {# False #}
{{ test_string is match('iao') }} {# False #}
{{ test_string is match('ciao', ignorecase=True) }} {# True #}
is search(find, ignorecase=False): verifica se find è presente in qualsiasi punto della stringa. Quando ignorecase è impostato su True, la ricerca delle corrispondenze non terrà conto delle differenze tra maiuscole e minuscole.
{% set test_string = "Ciao, testiamo la funzione" %}
{{ test_string is search('testiamo') }} {# True #}
{{ test_string is search('ciao') }} {# False #}
{{ test_string is search('iao') }} {# True #}
{{ test_string is search('Testiamo', ignorecase=True) }} {# True #}
Maggior Controllo
Filtri
I Filtri sono potenti strumenti che consentono di manipolare e formattare i dati all’interno dei template Puoi utilizzare i filtri per eseguire varie operazioni come formattare stringhe, effettuare operazioni aritmetiche e altro ancora. I filtri sono separati dalla variabile da un simbolo pipe |. È possibile concatenare più filtri. L’output di un filtro viene applicato a quello successivo.
Dettaglio
⬇️ string: viene utilizzato per convertire una variabile in una stringa.
{{ 44 | string }} {# numero in stringa #}
{{ ['elemento1','elemento2'] }} {# lista in stringa #}
{{ {'chiave1':'valoreq','chiave2':'valore2' } | string }} {# dizionario in stringa #}
⬇️ int: è utilizzato per convertire una variabile in un intero. Può anche accettare un valore di default che verrà utilizzato se la conversione non ha esito positivo. È importante notare che il filtro int non fornisce la possibilità di rilevare variabili non definite.
⬇️ float: è utilizzato per convertire una variabile in un numero decimale (virgola mobile). Può anche accettare un valore di default che verrà utilizzato se la conversione non ha esito positivo. È importante notare che il filtro float non fornisce la possibilità di rilevare variabili non definite.
⬇️ abs: è utilizzato per restituire il valore assoluto di un numero, ovvero il valore non negativo di quel numero. Indipendentemente dal fatto che il numero iniziale sia positivo o negativo, l’applicazione del filtro abs restituirà il suo valore positivo o zero.
⬇️ batch: è utilizzato per suddividere una sequenza (come una lista) in sotto-liste più piccole, chiamate “batch” o “gruppi”. Questo può essere utile quando si desidera suddividere un elenco di elementi in gruppi più gestibili.
{% set lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] %} {# stiamo creando una lista di numeri da 1 a 10 #}
{% set gruppi = lista | batch(3) %} {# suddividiamo la lista in gruppi da 3 elementi #}
{% for gruppo in gruppi %}
Gruppo: {{ gruppo }}
{% endfor %}
{# output: Gruppo: [1, 2, 3] Gruppo: [4, 5, 6] Gruppo: [7, 8, 9] Gruppo: [10] #}
⬇️ center: è utilizzato per centrare una stringa all’interno di una lunghezza specificata. Può essere utile per la formattazione di testo in contesti come le schede Markdown.
{{ "Titolo centrato" | center(30) }} {# stringa centrata all'interno di uno spazio di lunghezza 30 #}
⬇️ capitalize: è utilizzato per trasformare la prima lettera di una stringa in maiuscolo e tutte le altre lettere in minuscolo.
⬇️ default: è utilizzato per restituire un valore predefinito se il valore iniziale è indefinito (o valutato come falso in caso di configurazione con il secondo parametro a true).
{{ non_definito | default('Valore non definito') }} {# Valore non definito #}
{{ 'Valore definito' | default('Valore non definito') }} {# Valore definito #}
{{ true |default('Variabile false', true) }} {# True #}
{{ false |default('Variabile false', true) }} {# Variabile false #}
⬇️ dictsort: è utilizzato per ordinare un dizionario in base alle sue chiavi o valori. Questo filtro restituisce una lista di tuple, dove ogni tupla contiene una chiave e il corrispondente valore del dizionario.
⬇️ filesizeformat: è utilizzato per formattare una dimensione di file espressa in byte in un formato più leggibile, come kilobyte (KB), megabyte (MB) o gigabyte (GB), a seconda dell’ordine di grandezza.
⬇️ first: è utilizzato per restituire il primo elemento di una sequenza (come una lista o una stringa).
{% set lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{{ lista | first }} {# 'elemento1' #}
{{ 'Ciao' | first }} {# 'C' #}
⬇️ last: è utilizzato per restituire l’ultimo elemento di una sequenza, come una lista o una stringa.
{% set lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{{ lista | last }} {# elemento4 #}
{{ 'Ciao' | last }} {# 'o' #}
⬇️ groupby: è utilizzato per raggruppare una sequenza di oggetti in base a una chiave specificata. Restituisce un dizionario in cui le chiavi sono i valori della chiave specificata e i valori sono liste di oggetti corrispondenti a ciascun valore della chiave.
⬇️ reject: utilizzato per filtrare gli elementi di una sequenza rimuovendo quelli che soddisfano una determinata condizione rispetto a un attributo specifico di ciascun elemento
⬇️ select: utilizzato per selezionare gli elementi da una sequenza che soddisfano una condizione specifica. Questo filtro è utile quando si desidera filtrare gli elementi che rispettano una certa condizione.
⬇️ rejectattr: utilizzato per filtrare gli elementi di una sequenza rimuovendo quelli che soddisfano una determinata condizione rispetto a un attributo specifico.
⬇️ selectattr: utilizzato per filtrare gli elementi di una sequenza selezionando quelli che soddisfano una determinata condizione rispetto a un attributo specifico di ciascun elemento.
⬇️ replace: utilizzato per sostituire tutte le occorrenze di una sottostringa con un’altra all’interno di una stringa. Questo può essere utile quando si desidera modificare il contenuto di una variabile di testo.
{% set testo = "Questo è un esempio di replace." %}
{{ testo | replace('replace', 'sostituisci') }}
{# Questo è un esempio di sostituisci. #}
⬇️ reverse: utilizzato per invertire l’ordine degli elementi in una sequenza, come una lista.
⬇️ map: è utilizzato per applicare una funzione o un altro filtro a ciascun elemento di una sequenza, come una lista. Questa operazione è particolarmente utile quando si desidera eseguire una trasformazione coerente su tutti gli elementi di una sequenza.
{% set my_list = ['ciao', 'UppeR'] %}
{{ my_list | map('upper') | list }} {# ['CIAO', 'UPPER'] #}
{{ states.climate | map(attribute='name') | list }} {# lista di nome entità clima #}
⬇️ is_defined: consente di generare un errore se un valore o un oggetto non è definito. Questo può essere utile per convalidare un payload JSON. Il is_defined filtro consente di generare un errore se un valore o un oggetto non è definito.
{{ value_json.val | is_defined }} {# ERROR: 'value_json' NON è definito #}
{{ 'esempio definito' | is_defined }} {# esempio definito #}
⬇️ contains: può essere considerato simile all’operatore in, ma con un comportamento opposto.
Mentre l’operatore in permette di verificare se un valore è presente in una sequenza, il filtro contains permette di testare se una sequenza contiene un valore. Questa funzione può essere utilizzata come filtro o come test.
⬇️ timestamp_custom: serve per formattare un timestamp (un momento specifico nel tempo) secondo il formato desiderato per la rappresentazione della data e dell’ora.
⬇️ timestamp_local(default): è un filtro che converte un timestamp UNIX in una stringa nel formato ISO con fuso orario.
E’ possibile applicare un valore predefinito per evitare che il filtro generi un errore nel caso in cui la conversione del timestamp UNIX in formato ISO fallisca. In questo modo, se la conversione non è possibile, il filtro restituirà il valore predefinito invece di generare un errore.
⬇️ timestamp_utc(default): è un filtro che converte un timestamp UNIX in una stringa nel formato ISO senza fuso orario (UTC).#
E’ possibile applicare un valore predefinito per evitare che il filtro generi un errore nel caso in cui la conversione del timestamp UNIX in formato ISO fallisca. In questo modo, se la conversione non è possibile, il filtro restituirà il valore predefinito invece di generare un errore.
⬇️ bitwise: è possibile eseguire operazioni con bit.
value_one|bitwise_and(value_two): esegue un’operazione bit per bit di “AND” tra i due valori
{{ 7 | bitwise_and(3) }} {# 1 #}
value_one|bitwise_or(value_two): Questo filtro esegue un’operazione bit per bit di “OR” tra i due valori.
{{ 7 | bitwise_or(3) }} {# 7 #}
value_one|bitwise_xor(value_two): Questo filtro esegue un’operazione bit per bit di “XOR” (o esclusivo OR) tra i due valori.
{{ 7 | bitwise_xor(3) }} {# 6 #}
ord: restituirà per una stringa di lunghezza uno un numero intero che rappresenta il punto di codice Unicode del carattere quando l’argomento è un oggetto Unicode o il valore del byte quando l’argomento è una stringa a 8 bit
{{ "A" | ord }} {# 65 #}
{{ "1" | ord }} {# 49 #}
⬇️ state_translated; restituisce lo stato tradotto di un’entità utilizzando la lingua attualmente configurata in homeassistant.
⬇️ slugify(separator="default= '_' "): viene utilizzato per convertire una stringa in un “slug”, sostituendo gli spazi con il separatore specificato (di default, trattino basso _).
{% set title = "Ciao, aggiungi un separatore!" %}
{{ title | slugify }} {# ciao_aggiungi_un_separatore #}
{{ title | slugify(separator="default= '_' ") }} {# ciaodefault= '_' aggiungidefault= '_' undefault= '_' separatore #}
⬇️ ordinal: viene utilizzato per converte i numeri interi in numeri ordinali.
La struttura condizionale if, elif, else, e endif è un modo per controllare il flusso del template in base a condizioni.
Dettaglio
if: L’istruzione if inizia una sezione di codice condizionale, e il blocco di codice successivo verrà eseguito solo se la condizione associata all’if è valutata come vera. In altre parole, il codice all’interno del blocco if viene eseguito solo quando la condizione specificata è verificata come true. Grazie per la chiara riformulazione.
elif (else if): L’istruzione elif (else if) inizia una sezione di codice condizionale aggiuntiva. Il blocco di codice successivo verrà eseguito solo se la condizione associata all’elif è valutata come vera. In caso contrario, se la condizione dell’elif è falsa, il flusso del codice continuerà a valutare le successive clausole elif o, in mancanza di ulteriori clausole, passerà all’eventuale blocco else.
else: L’istruzione else inizia una sezione di codice condizionale alternativo. Il blocco di codice successivo verrà eseguito solo se nessuna delle condizioni precedenti (if o eventuali clausole elif) è valutata come vera. In altre parole, il blocco di codice else rappresenta il caso di fallback, che viene eseguito quando tutte le condizioni precedenti risultano false.
endif: L’istruzione endif segna la fine della sezione di codice condizionale in Jinja2. Tutte le istruzioni successive a endif verranno eseguite indipendentemente dalle condizioni precedenti. In pratica, endif chiude la costruzione condizionale aperta con if, elif, e else, indicando che tutte le alternative condizionali sono state considerate e che il flusso del codice dovrebbe continuare normalmente.
{% set numero = 54 %} {# Inizializza una variabile numero es.54 #}
{% if numero > 90 %} {# Inizia un blocco condizionale. Se il valore della variabile è maggiore di 90, eseguirà il blocco di codice successivo #}
Il numero è maggiore di 90.
{% elif numero > 70 %} {# Altra condizione. Se la condizione precedente non è vera, verifica se il numero è maggiore di 70. Se è vero, eseguirà il blocco di codice successivo. #}
Il numero è maggiore di 70.
{% elif numero >= 50 %} {# Altra condizione. Se la condizione precedente non è vera, verifica se il numero è maggiore o uguale a 50. Se è vero, eseguirà il blocco di codice successivo #}
Il numero è maggiore o uguale a 50.
{% else %} {# Questo blocco viene eseguito se nessuna delle condizioni precedenti è vera #}
Il numero è minore di 50.
{% endif %}
In Home Assistant, è possibile scrivere condizioni in una sintassi più breve quando non è necessario specificare una clausola “elif“.
{{ 'ACCESA' if is_state('light.luce_studio', 'on') else 'SPENTA' }}
Inoltre, Home Assistant offre il filtro iif, che consente di esprimere condizioni in modo più breve ed immediato. La sintassi di base è: {{ iif(condition, if_true, if_false, if_none) }}
condition: La condizione da valutare.
if_true: Il valore restituito se la condizione è vera. Opzionale; se omesso, restituisce True.
if_false: Il valore restituito se la condizione è falsa. Opzionale; se omesso, restituisce False.
if_none: Il valore restituito se la condizione è None. Opzionale; se omesso, restituisce None.
Si noti che il filtro iif non segue il comportamento di cortocircuito tipico di un’istruzione condizionale standard, che interrompe l’esecuzione al primo risultato positivo.
Invece, tutte le espressioni fornite (if_true, if_false, if_none) vengono valutate indipendentemente dalla condizione. Questo significa che entrambe le espressioni vengono esaminate, indipendentemente dal risultato della condizione, il che può causare problemi, specialmente in situazioni complesse o con valori che potrebbero causare errori.
Ciclo For
Il ciclo for è una struttura di programmazione che ti permette di ripetere un blocco di istruzioni per ogni elemento in una sequenza di dati. Ogni volta che il ciclo “gira” (itera), il tuo programma può fare qualcosa con l’elemento corrente della sequenza. In termini più semplici, il ciclo for è come un incaricato di eseguire una serie di compiti, uno alla volta, per ciascun elemento in una lista o un’altra collezione di dati.
In questo esempio, viene creata una variabile my_list contenente una lista di tre elementi (‘Primo’, ‘Secondo’, ‘Terzo’). Successivamente, un ciclo for attraversa ogni elemento della lista, stampando ciascun elemento. L’output finale è la stringa concatenata degli elementi della lista, senza spazi tra di essi: ‘PrimoSecondoTerzo’.
{% set my_list = ['Primo', 'Secondo', 'Terzo'] %}
{% for ordine in my_list %}
{{ ordine }}
{% endfor %}
{# 'Primo Secondo Terzo' #}
Può essere impiegata per iterare su ogni coppia chiave-valore presente nel dizionario.
{% set my_dict = {'Primo': 1, 'Secondo': 2, 'Terzo': 3} %}
{% for chiave, valore in my_dict.items() %}
{{ chiave }}: {{ valore }}
{% endfor %}
{# 'Primo: 1 Secondo: 2 Terzo: 3' #}
⬇️ else: Se non è avvenuta alcuna iterazione perché la sequenza era vuota o il filtro ha rimosso tutti gli elementi dalla sequenza, puoi eseguire il rendering di un blocco predefinito utilizzando else.
{% set my_lista = [ 5, 55 ] %} {# lista composta da numeri #}
{% for valore in my_lista if valore is string %} {# applicato filtro string #}
Stringa
{% else %}
Numero
{% endfor %}
{# Numero #}
⬇️ break: è un’estensione aggiunta ad HomeAssistant utilizzata per interrompere immediatamente l’esecuzione del loop quando una specifica condizione viene soddisfatta.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{% if valore == 'elemento2' %}
{{ valore }}
{% break %} {# Esci dal ciclo quando si verifica la condizione desiderata #}
{% else %}
{{ valore }}
{% endif %}
{% endfor %}
{#
elemento1
elemento2
#}
⬇️ continue: è un’estensione aggiunta ad Home Assistant utilizzata che, quando viene eseguita, interrompe immediatamente l’esecuzione dell’iterazione corrente del ciclo e passa immediatamente alla successiva.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{% if valore == 'elemento2' %}
{% continue %} {# Salta alla prossima iterazione se il valore da evitare è trovato #}
{% else %}
{{ valore }}
{% endif %}
{% endfor %}
{#
elemento1
elemento3
elemento4
#}
All'interno di un blocco for, puoi accedere ad alcune variabili speciali
⬇️ loop.index: rappresenta l’indice corrente durante l’iterazione di un ciclo. Esso restituisce la posizione numerica dell’elemento in questione, partendo da 1.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.index }}
{% endfor %}
{#
1
2
3
4
#}
⬇️ loop.index0: rappresenta l’indice corrente durante l’iterazione di un ciclo, partendo da 0. A differenza di loop.index che inizia da 1, loop.index0 restituisce l’indice partendo da 0.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.index0 }}
{% endfor %}
{#
0
1
2
3
#}
⬇️ loop.revindex: rappresenta l’indice inverso corrente durante l’iterazione di un ciclo. Esso restituisce la posizione inversa numerica dell’elemento in questione, partendo da 1 per l’ultimo elemento, 2 per il penultimo, e così via.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.revindex }}
{% endfor %}
{#
4
3
2
1
#}
⬇️ loop.revindex0: rappresenta l’indice inverso corrente durante l’iterazione di un ciclo, partendo da 0 per l’ultimo elemento, 1 per il penultimo, e così via. A differenza di loop.revindex che inizia da 1, loop.revindex0 restituisce l’indice inverso partendo da 0
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.revindex0 }}
{% endfor %}
{#
3
2
1
0
#}
⬇️ loop.first: restituisce True durante la prima iterazione di un ciclo e False durante le iterazioni successive.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.first }}
{% endfor %}
{#
True
False
False
False
#}
⬇️ loop.last: restituisce True durante l’ultima iterazione di un ciclo e False durante le iterazioni precedenti.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.last }}
{% endfor %}
{#
False
False
False
True
#}
⬇️ loop.length: restituisce il numero totale degli elementi nella sequenza su cui si sta iterando.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.length }}
{% endfor %}
{#
4
4
4
4
#}
⬇️ loop.cycle: consente di assegnare dinamicamente diversi valori in modo sequenziale a ciascun elemento all’interno di un ciclo.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for valore in my_lista %}
{{ loop.cycle('primo', 'secondo') }}
{% endfor %}
{#
primo
secondo
primo
secondo
#}
⬇️ loop.previtem: rappresenta l’elemento della precedente iterazione del ciclo. Indefinito durante la prima iterazione.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for elemento in my_lista %}
Elemento corrente: {{ elemento }}
{%- if loop.previtem is defined %}
Elemento precedente: {{ loop.previtem }}
{% else %}
Nessun elemento precedente (siamo al primo elemento)
{% endif %}
{% endfor %}
{#
Elemento corrente: elemento1
Nessun elemento precedente (siamo al primo elemento)
Elemento corrente: elemento2
Elemento precedente: elemento1
Elemento corrente: elemento1
Elemento precedente: elemento2
Elemento corrente: elemento4
Elemento precedente: elemento1
#}
⬇️ loop.nextitem: rappresenta l’elemento della successiva iterazione del ciclo. Non definito durante l’ultima iterazione.
{% set my_lista = ['elemento1', 'elemento2', 'elemento3', 'elemento4'] %}
{% for elemento in my_lista -%}
Elemento corrente: {{ elemento }}
{%- if loop.nextitem is defined %}
Elemento successivo: {{ loop.nextitem }}
{% else %}
Nessun elemento successivo (siamo all'ultimo elemento)
{% endif %}
{% endfor %}
{#
Elemento corrente: elemento1
Elemento successivo: elemento2
Elemento corrente: elemento2
Elemento successivo: elemento3
Elemento corrente: elemento3
Elemento successivo: elemento4
Elemento corrente: elemento4
Nessun elemento successivo (siamo all'ultimo elemento)
#}
⬇️ loop.changed(*val): restituisce True se uno o più valori sono cambiati rispetto all’iterazione precedente del ciclo.
{% set my_lista = ['elemento1', 'elemento2', 'elemento2', 'elemento4'] %}
{% for valore in my_lista %}
{{- loop.changed(valore)}}
{% endfor %}
{#
True ("elemento1: Prima iterazione")
True ("elemento2: Il valore è cambiato rispetto all'iterazione precedente.")
False ("elemento2: Il valore è lo stesso dell'iterazione precedente.")
True ("elemento4: Il valore è cambiato rispetto all'iterazione precedente.")
#}
Macro
Le macro sono blocchi di codice riutilizzabili che puoi definire una volta e poi chiamare più volte. Immagina una macro come un “pezzetto” di codice che crei una volta e poi puoi “incollarlo” nel tuo template ogni volta che ne hai bisogno. È come avere un piccolo blocco di istruzioni che puoi riutilizzare senza riscrivere tutto il codice ogni volta. Semplicemente lo richiami quando serve, rendendo il tuo template più pulito e facile da gestire.
Per definirla, utilizza la parola chiave macro, seguita da un nome a tua scelta per la macro e dalle variabili desiderate racchiuse tra parentesi. Puoi specificare più variabili nelle macro di Jinja2, separandole con virgole, e puoi assegnare valori di default a ciascuna variabile.
{% macro test(test_varibile, variabile_con_default='Italiano') %}
Ciao {{ test_varibile }} sei {{ variabile_con_default }}?
{% endmacro %}
{{ test('Marco') }} {# Ciao Marco sei Italiano? #}
{{ test('Henrik', 'Francese') }} {# Ciao Henrik sei Francese? #}
In Home Assistant, è possibile organizzare modelli Jinja2 riutilizzabili nella cartella custom_templates all’interno della directory config. Questa pratica aiuta a semplificare il codice, evitando la ripetizione di codice complesso in più template. I file contenenti i modelli devono avere estensione .jinja.
Esempio
Crei un file chiamato test_macro.jinja nella cartella custom_templates con una macro chiamata format_entity.
Quindi, puoi riutilizzare la macro importandola in un template.
{% from 'test_macro.jinja' import format_entity %}
{{ format_entity('sensor.temperature') }}
{# Temperatura - 21 #}}
In questo modo, hai dichiarato la macro format_entity nel file test_macro.jinja e poi l’hai importata e utilizzata in un altro template. La macro prende una variabile entity_id e restituisce una stringa formattata con il nome e lo stato dell’entità specificata (‘sensor.temperature’ nell’esempio).
Namespace
La funzione namespace è utilizzata per organizzare e gestire i dati all’interno dei template.
È possibile creare un namespace utilizzando la funzione namespace() per organizzare variabili correlate.
{% set my_namespace = namespace(count=0, devices=[]) %}
In questo esempio, my_namespace è un namespace che contiene una variabile count e una lista vuota chiamata devices.
È possibile aggiornare i valori all’interno del namespace utilizzando la sintassi my_namespace.variable = valore. Mentre puoi accedere direttamente ai valori del namespace utilizzando la sintassi namespace.variablename.
L’utilizzo del namespace può essere estremamente comodo per estrapolare i dati all’interno di un ciclo for e consentire una seconda iterazione su di essi o ottenere una semplice lista.
{%- for a in device_entities('c145d6e3182ba054d154c689b25cd881') %}
{{- a }}
{%- endfor %}
{# output = esempio,binary_sensor.luce_studiosensor.wifi_luce_studiosensor.luce_studio_uptimeupdate.studio_firmwarebutton.luce_studio_restartswitch.detached_luce_studiolight.luce_studio #}
{% set my_namespace = namespace(devices=[]) %}
{%- for a in device_entities('c145d6e3182ba054d154c689b25cd881') %}
{% set my_namespace.devices = my_namespace.devices + [a] %}
{%- endfor %}
{{ my_namespace.devices }}
{# output = ['binary_sensor.luce_studio', 'sensor.wifi_luce_studio', 'sensor.luce_studio_uptime', 'update.studio_firmware', 'button.luce_studio_restart', 'switch.detached_luce_studio', 'light.luce_studio'] #}
Nell’esempio fornito, vediamo due approcci diversi per gestire le entità di un dispositivo all’interno di un template.
Senza utilizzo del namespace: Utilizzando un semplice ciclo for, otteniamo una stringa che rappresenta l’elenco delle entità del dispositivo. Questo approccio è limitato perché otteniamo solo una stringa e non possiamo facilmente utilizzare questa lista di entità in altre parti del template.
Con utilizzo del namespace: Utilizzando il namespace, creiamo una lista di entità del dispositivo durante l’iterazione. Questo ci permette di mantenere una lista organizzata e riutilizzabile delle entità all’interno del template. Il namespace offre un modo conveniente per organizzare e gestire questi dati, rendendo più semplice l’accesso e l’utilizzo delle informazioni all’interno del template.
Estensione template HomeAssistant
Nell’ambito di Home Assistant, le “estensioni di template” si riferiscono a personalizzazioni e funzionalità aggiuntive integrate nei modelli. Queste estensioni consentono di arricchire e adattare le configurazioni, aggiungendo nuovi filtri, e funzioni.
Puoi pensare a queste estensioni come a librerie o moduli supplementari, progettati per ampliare le funzionalità di base di Jinja2 specificamente per Home Assistant.
Stati e attributi
È importante comprendere la distinzione tra un ‘oggetto di stato’ e uno ‘stato di un oggetto’. La differenza tra un “oggetto di stato” e uno “stato di un oggetto” può sembrare sottile, ma è importante comprendere il contesto specifico in cui vengono utilizzati questi termini.
Lo stato di un oggetto: Si riferisce al valore corrente un’entità specifica in un determinato momento. Ad esempio, lo stato di un sensore di temperatura è la temperatura attuale. A questi non è possibile applicare filtri.
Oggetto di stato: Si riferisce alla struttura dati completa che contiene tutte le informazioni associate allo stato di un’entità. Questo oggetto di stato comprende non solo il valore corrente ma anche altri attributi come l’unità di misura, il timestamp dell’ultimo aggiornamento, e altri dati correlati all’entità.
Quindi, puoi dire “lo stato di un oggetto” è più specificamente il valore attuale di un’entità, mentre “oggetto di stato” è un termine più ampio che abbraccia tutte le informazioni correlate a tale stato all’interno del sistema.
Oggetto di stato
Attraverso l’utilizzo della variabile states in Home Assistant, abbiamo la possibilità di esaminare l’intero oggetto di stato, offrendo un ampio margine di flessibilità per l’applicazione di ulteriori filtri. Ad esempio, mediante l’istruzione {{ states | map(attribute='entity_id') | list }}, possiamo generare un elenco completo di tutte le entità attualmente presenti nel sistema.
Se il nostro interesse è rivolto a un particolare dominio, possiamo restringere la nostra ricerca utilizzando {{ states.light | map(attribute='entity_id') | list }}, ottenendo così un elenco di tutti gli oggetti di stato associati al dominio “light” mappando gli entity_id. Lo stesso risultato può essere ottenuto attraverso la sintassi alternativa {{ states['light'] | map(attribute='entity_id') | list }} o utilizzando la funzione expand offrendo la possibilità di creare una lista ordinata e senza entità duplipate.
Per completezza, è possibile accedere rapidamente allo stato e ai vari attributi di una singola entità (chiavi) utilizzando direttamente l’espressione della variabile di stato. Tuttavia, è consigliabile fare attenzione e evitare questa pratica quando possibile, specialmente per evitare errori e messaggi di errore quando l’entità non è ancora completamente pronta o disponibile. Preferibilmente, è consigliato utilizzare le funzioni dello stato di un oggetto per garantire una gestione più robusta delle entità.
{{ states.light.luce_studio.state }} {# on/off #}
{{ states['light.luce_studio'].state }} {# on/off #}
{{ states.light.luce_studio.attributes.friendly_name }} {# Luce Studio #}
{{ states['light.luce_studio'].attributes.friendly_name }} {# Luce Studio #}
Oltre alle chiavi state ed attributes che hanno come detto una funzione personalizzata possiamo accedere alle altre chiavi del oggetto modo simile.
Possiamo ottenere lo stato di un oggetto utilizzando la variabile states in combinazione con funzioni specifiche. Ad esempio, con l’espressione {{ states('light.luce_studio') }}, possiamo estrarre direttamente lo stato dell’entità “luce_studio”.
{{ states('light.luce_studio') }} {# on/off #}
La funzione state_translated restituisce lo stato tradotto di un’entità utilizzando la lingua attualmente configurata in homeassistant. E’ possibile utilizzare la funzione anche come filtro.
In aggiunta, possiamo controllare la formattazione di output di un sensore utilizzando le funzioni rounded e with_unit. La funzione rounded offre la possibilità di limitare la visualizzazione a due numeri decimali del valore del sensore o di escluderli del tutto. D’altra parte, la funzione with_unit consente di aggiungere l’unità di misura alla visualizzazione del valore del sensore restituendo una stringa.
È possibile accedere allo stato di un attributo specifico di un sensore utilizzando la funzione state_attr in Home Assistant. Basta scrivere la funzione state_attr e specificare tra parentesi l’entità del sensore e l’attributo desiderato, separati da una virgola.
{{ state_attr('sensor.generale_energy', 'device_class') }} {# energy #}
{{ state_attr('sensor.generale_energy', 'friendly_name') }} {# Generale energy #}
In Home Assistant, è possibile confrontare lo stato di un’entità o lo stato di un attributo di un’entità con uno stato specificato. Oltre agli operatori di confronto, puoi utilizzare le funzioni specifiche is_state e is_state_attr per effettuare questi confronti in modo più leggibile.
Per quanto riguarda lo stato di un’entità, puoi anche confrontarlo con un elenco di stati, in alternativa alla funzione in, per verificare se lo stato corrisponde a uno qualsiasi degli stati specificati nell’elenco.
La funzione has_value verifica se l’entità specificata non è sconosciuta o non disponibile, mentre is_hidden_entity indica se l’entità è stata nascosta, quindi non visualizzabile sulla dashboard. has_value può essere utilizzato come filtro.
Dedichiamo una breve nota alla gestione dei gruppi. Nonostante sia possibile accedere alle entità che lo compongono tramite l’attributo entity_id, possiamo anche avvalerci della funzione expand, che ci fornisce un accesso diretto agli oggetti di stato delle entità. Questo ci permette di ordinare e ottenere un elenco unico di entità nel gruppo.
Un piccolo riepilogo per capire in linea generale come Home Assistant organizza le informazioni in modo gerarchico e concettuale.
Entità: Un’entità si riferisce a un’unità individuale che rappresenta un elemento specifico all’interno del sistema di Home Assistant. Queste entità possono essere associate a diversi concetti, inclusi automazioni, script o singole caratteristiche di un dispositivo. Ad esempio, consideriamo un dispositivo relè che può essere suddiviso in entità separate per il suo stato (acceso/spento), la potenza assorbita, l’energia consumata e così via. Ad ogni entità è associato un ID univoquo.
Integrazioni: Le integrazioni rappresentano i vari componenti o piattaforme supportate da Home Assistant. Questi possono includere dispositivi hardware, servizi cloud, protocolli di comunicazione, e altro ancora. Ad esempio, l’integrazione ZHA supporta dispositivi Zigbee come luci, sensori, ecc.
Dispositivi: Un dispositivo è un oggetto fisico o virtuale che comunica con Home Assistant tramite un’integrazione. Ad esempio, un dispositivo potrebbe essere una lampada Zigbee, un sensore di temperatura o una videocamera. Ogni dispositivo è associato a un’area ed ha un ID univoquo.
Etichette: consentono di raggruppare elementi, indipendentemente dalla loro posizione fisica o tipo. Puoi assegnare etichette ad aree, dispositivi, entità, automazioni, scene, script e aiutanti.
Aree: Le aree sono utilizzate per organizzare i dispositivi all’interno della tua casa. Possono rappresentare stanze o qualsiasi altra suddivisione logica dello spazio abitativo. Ad esempio, potresti avere un’area chiamata “Salotto” che include tutti i dispositivi presenti in quella stanza. Ad ogni area è associato un ID univoquo.
Piani: rappresenta un raggruppamento logico di aree che corrispondono ai piani fisici della tua casa. I dispositivi e le entità non possono essere assegnati direttamente ai piani, ma sono assegnati alle aree che compongono il piano. I piani possono essere utilizzati nelle automazioni e negli script come destinazione per le azioni. Ad esempio, puoi configurare un’automazione per spegnere tutte le luci del piano terra quando vai a letto.
Zone: Le Zone in Home Assistant costituiscono rappresentazioni di specifiche regioni geografiche sulla Terra. L’utilizzo di queste zone permette di delineare e identificare aree di interesse all’interno del sistema, come ad esempio casa, lavoro, palestra, e così via. Quando un dispositivo autenticato su Home Assistant, con l’app companion installata e l’utente loggato, viene individuato all’interno di una zona designata, il sistema associa automaticamente lo stato di quest’ultimo al nome della zona corrispondente. Ad esempio, se un dispositivo si trova all’interno della zona “home” (casa), il sistema assegnerà lo stato del dispositivo a quella zona specifica, semplificando così il monitoraggio e la gestione dei dispositivi in base alla loro posizione geografica. Ad ogni zona è associato un ID univoquo.
Voce di configurazione
⬇️ config_entry_id: o voce di configurazione rappresenta le informazioni specifiche di configurazione associate a un componente o un’entità.
Una voce di configurazione rappresenta i dettagli specifici di come un componente o un’entità è configurato nel sistema di Home Assistant. Questa funzione può essere utilizzata anche come filtro.
{{ config_entry_id('sensor.comodino_mattia_rssi') }} {# config_entry_id di una entità #}
{{ 'sensor.comodino_mattia_rssi' | config_entry_id }}
{# esempio utilizzo filtro #}
{{ states | map(attribute='entity_id') | map('config_entry_id') | reject('eq', None) | unique | list }}
{# esempio utilizzo #}
{% set target = config_entry_id('update.home_assistant_core_update') %} {# Imposta l'ID della voce di configurazione #}
{%- for entity in states -%}
{% if config_entry_id(entity.entity_id) == target %}
{{ entity.entity_id }}
{%- endif %}
{%- endfor %}
{# elenca gli entity_id associati alla variabile 'target' #}
Dispositivi / Devices
⬇️ device_id(device_or_entity_id): restituisce l’ID del dispositivo associato, ottenibile sia da un entity_id che dal nome dispositivo. Questa funzione può essere utilizzata anche come filtro.
⬇️ device_entities(device_id): restituisce un elenco delle entità collegate a un determinato device_id. Questa funzione può essere utilizzata anche come filtro.
⬇️ device_attr(device_id_or_entity_id, attr_name): restituisce il valore dell’attributo del dispositivo, ottenibile sia da un entity_id che dal device_id. Questa funzione può essere utilizzata anche come filtro. È possibile verificare gli attributi disponibili per un dispositivo accedendo al file core.device_registry (importante non effettuare modifiche al file).
⬇️ is_device_attr(device_id_or_entity_id, attr_name, attr_value): restituisce True se il valore dell’attributo del dispositivo specificato corrisponde al valore specifico fornito. È possibile verificare gli attributi disponibili per un dispositivo accedendo al file core.device_registry (importante non effettuare modifiche al file).
{{ is_device_attr('light.luce_studio', 'manufacturer', 'Espressif') }} {# true #}
{{ is_device_attr('switch.dyson_continuous_monitoring', 'manufacturer', 'Dyson') }} {# false #}
{{ is_device_attr('c145d6e3182ba054d154c689b25cd881', 'manufacturer', 'Espressif') }} {# true #}
{{ states | map(attribute='entity_id') | select('is_device_attr', 'manufacturer', 'Shelly')| select('is_device_attr', 'model', 'Shelly 1') | list }}
{# esempio di utilizzo che restituisce tutte le entity_id dei dispositivi shelly 1 #}
Aree / Areas
⬇️ areas(): restituisce una lista di tutte le ID area
⬇️ area_id(device_id_or_entity_id_or_area_name): è possibile recuperare l’ID dell’area associata utilizzando l’ID del dispositivo (device_id), l’ID dell’entità (entity_id) e il nome dell’area.
Questa funzione può essere utilizzata anche come filtro.
{{ area_id('c145d6e3182ba054d154c689b25cd881') }} {# device_id #}
{{ area_id('Studio') }} {# area_name #}
{{ area_id('light.luce_studio') }} {# entity_id #}
{{ 'Studio' | area_id }} {# esempio uso come filtro #}
{# tutte restituisco l'area_id es. a75bbae460334cd1ab6a5b8051f7f190 #}
⬇️ area_name(device_id_or_entity_id_or_area_id): è possibile recuperare nome dell’area associata utilizzando l’ID del dispositivo (device_id), l’ID dell’entità (entity_id) e area id.
Questa funzione può essere utilizzata anche come filtro.
{{ area_name('c145d6e3182ba054d154c689b25cd881') }} {# device_id #}
{{ area_name('a75bbae460334cd1ab6a5b8051f7f190') }} {# area_id #}
{{ area_name('light.luce_studio') }} {# entity_id #}
{{ 'light.luce_studio' | area_name }} {# esempio uso con filtro #}
{# tutte restituisco il nome dell'area es. Studio #}
⬇️ area_entities(area_name_or_area_id): è possibile ottenere una lista delle entity_id associate a un’area, utilizzando sia il nome dell’area che l’ID dell’area.
Questa funzione può essere utilizzata anche come filtro.
{{ area_entities('a75bbae460334cd1ab6a5b8051f7f190') }} {# area_id #}
{{ area_entities('Studio') }} {# area_name #}
{{ 'Studio' | area_entities }} {# esempio uso come filto #}
{# tutte restituisco le entità dell'area es. ['sensor.samsung_m2070_toner', .... 'light.luce_bagno'] #}
{{ states.light | selectattr('entity_id', 'in', area_entities('Studio'))| map(attribute='entity_id') |list}}
{# esempio utilizzo che restituisce le entità id light in Studio #}
⬇️ area_devices(area_name_or_area_id): è possibile ottenere una lista dei device_id associati a un’area, utilizzando sia il nome dell’area che l’ID dell’area.
Questa funzione può essere utilizzata anche come filtro.
{{ area_devices('a75bbae460334cd1ab6a5b8051f7f190') }} {# area_id #}
{{ area_devices('Studio') }} {# area_name #}
{{ 'Studio' | area_devices }} {# esempio uso come filto #}
{# tutte restituisco id_device dell'area es. ['d2f8f1e40c064c318e7539af08a46fb3', ..... 'a7338d3803a3deebf32916471da3051f'] #}
{{ states.light | map(attribute='entity_id') | map('device_id') | reject ('eq', None) | unique | select('in',area_devices('Studio') ) | list }}
{# esempio utilizzo che restituisce id_device delle entità id light in Studio #}
Integrazioni
⬇️ integration_entities(integration_or_title):restituisce una lista delle entity_id collegate a una particolare integrazione. Puoi utilizzare il nome dell’integrazione e, se sono state configurate più istanze per la stessa integrazione, puoi anche fare riferimento al titolo impostato per tale integrazione.
{{ integration_entities('shelly') }} {# [ "button.frigorifero_reboot", ........... "light.luce_cucina" } #}
{{ states.light | selectattr('entity_id', 'in', integration_entities('shelly')) | map(attribute='entity_id') |list}}
{# esempio utilizzo per ottenere elenco di tutte light con integrazione shelly #}
Piani / Floors
⬇️ floors(): restituisce una lista di tutte le ID dei piani.
⬇️ floor_id(device_id_or_entity_id_or_area_name): è possibile recuperare l’ID del piano associata utilizzando l’ID del dispositivo (device_id), l’ID dell’entità (entity_id), il nome dell’area (area_name) e l’ID dell’area (area_id).
Questa funzione può essere utilizzata anche come filtro.
{{ floor_id('c145d6e3182ba054d154c689b25cd881') }} {# device_id #}
{{ floor_id('246326a3d1764a1ca80277498b6512fb') }} {# area_id#}
{{ floor_id('Studio') }} {# area_name #}
{{ floor_id('light.luce_studio') }} {# entity_id #}
{{ 'Primo' | floor_id}} {# esempio uso come filtro #}
{# tutte restituisco l'floor_id es. a75bbae460334cd1ab6a5b8051f7f190 #}
⬇️ floor_name(device_id_or_entity_id_or_area_id): è possibile recuperare nome del piano associata utilizzando l’ID del dispositivo (device_id), l’ID dell’entità (entity_id), l’ID area (area_id) ed l’ID del piano (floor_id).
Questa funzione può essere utilizzata anche come filtro.
{{ floor_name('c145d6e3182ba054d154c689b25cd881') }} {# device_id #}
{{ floor_name('a75bbae460334cd1ab6a5b8051f7f190') }} {# area_id #}
{{ floor_name('v75bbas460fggfgdfcd1ab6a51f7f190') }} {# floor_id #}
{{ floor_name('light.luce_studio') }} {# entity_id #}
{{ 'light.luce_studio' | floor_name}} {# esempio uso con filtro #}
{# tutte restituisco il nome del piano es. Primo #}
⬇️ floor_areas(floor_name_or_id): è possibile recuperare le aree associate al piano utilizzando l’ID del piano (floor_id) ed il nome del piano (floor_name).
Questa funzione può essere utilizzata anche come filtro.
{{ floor_name('Primo') }} {# floor_name#}
{{ floor_name('v75bbas460fggfgdfcd1ab6a51f7f190') }} {# floor_id #}
{{ floor_name('light.luce_studio') }} {# entity_id #}
{{ 'Primo' | floor_name}} {# esempio uso con filtro #}
{# tutte restituisco il le aree associate es. ['Cucina', 'Studio'] #}
Etichette / Labels
⬇️ labels(): è possibile recuperare la lista completa degli ID etichette o l’ID etichette assegnate all’ID area (area_id), ID dispositivo (device_id) o ID entità (entity_id).
Questa funzione può essere utilizzata anche come filtro.
⬇️ label_devices(label_name_or_id): è possibile recuperare la lista degli ID dispositivi (device_id) associate al nome (label_name) o ID etichetta (label_id).
Questa funzione può essere utilizzata anche come filtro.
⬇️ label_entities(label_name_or_id): è possibile recuperare la lista delle ID entità (entity_id) associate al nome (label_name) o ID etichetta (label_id).
Questa funzione può essere utilizzata anche come filtro.
Esistono diversi formati di rappresentazione della data e dell’ora, ciascuno con la propria convenzione. Ecco alcuni dei formati più comuni:
Fuso orario: È una rappresentazione numerica del tempo che restituisce la data e l’ora attuali (datetime) basate sul fuso orario configurato in Home Assistant. Esempio: 2024-02-05 22:10:54.953156+01:00
UTC (Coordinated Universal Time): È una rappresentazione numerica del tempo che restituisce l’orario attuale (datetime), ignorando eventuali impostazioni di ora legale. Esempio: 2024-02-05 21:10:54.953167+00:00
Unix Timestamp: È una rappresentazione numerica del tempo che conta il numero di secondi trascorsi dal 1° gennaio 1970 00:00:00 UTC. Esempio: 1707167454.953173 rappresenta il 5 febbraio alle 21:10:54
ISO 8601: È uno standard internazionale che specifica il formato di rappresentazione delle date e degli orari. Utilizza la lettera “T” come separatore tra la data e l’ora. Esempio: 2024-02-05T22:10:54.953190+01:00
Formato H24 (orario militare): È un modo di rappresentare il tempo utilizzando un orologio a 24 ore senza indicare AM o PM. L’orario va da 00:00 a 23:59. Esempio: 22:10 rappresenta le 10:10 del pomeriggio.
Dettaglio
⬇️ now(): È una funzione che restituisce la data e l’ora con fuso orario, altri attributi datetime.
L’utilizzo causerà l’aggiornamento dei template all’inizio di ogni nuovo minuto.
⬇️ today_at(): è una funzione che converte una stringa contenente un formato H24 in un oggetto datetime con fuso orario, tenendo conto del fuso orario specificato.
L’utilizzo causerà l’aggiornamento dei template all’inizio di ogni nuovo minuto.
⬇️ as_datetime(): è una funzione che coverte una stringa con formato Fuso orario, UTC , ISO 8601 o Unix in un oggetto che rappresenta la data e l’ora corrispondenti.
L’utilizzo causerà l’aggiornamento dei template all’inizio di ogni nuovo minuto.
{{ as_datetime('2024-02-05T10:30:00+01:00') }} {# ISO: 2024-02-05 10:30:00+01:00 #}
{{ as_datetime('2024-02-05 10:30:00+01:00') }} {# Con e senza fuso orario: 2024-02-06 10:30:00+01:00 #}
{{ as_datetime('1707125400.0') }} {# Unix: 2024-02-05 09:30:00+00:00 #}
⬇️ as_timestamp(): è una funzione che coverte una stringa con formato Fuso orario, UTC o ISO 8601 in un oggetto che rappresenta la data e l’ora corrispondenti nel formato Unix.
Se fallisce, restituisce il valore default o, se omesso, genera un errore. Questa funzione può essere utilizzata anche come filtro.
⬇️ as_local(): è una funzione che converte un oggetto datetime nell’ora locale corrispondente.
Questa funzione può essere utilizzata anche come filtro.
{{ as_local(utcnow()) }}
{{ as_local(state_attr('script.reset_sensori_frigorifero', 'last_triggered')) }}
{{ as_local(as_datetime('2024-02-05T10:30:00+00:00')) }}
{{ utcnow() | as_local }} {# esempio filtro #}
{{ state_attr('script.reset_sensori_frigorifero', 'last_triggered') | as_local}} {# esempio filtro #}
{{ as_local(as_datetime('2024-02-05T10:30:00+00:00')) | as_local}} {# esempio filtro #}
{# tutti restituisco la data con formato 2024-02-06 21:49:00.064432+01:00 #}
⬇️ relative_time(): è un funzione che rappresentare l’intervallo di tempo trascorso dalla data fornita fino ad oggi. Dalla versione di Homeassistant 2024.5 questa funzione è stata migliorata da time_since(datetime, precision) e time_until(datetime, precision).
Converte un oggetto datetime che rappresenta una data passata e restituisce una stringa che rappresenta l’età relativa in termini di secondi, minuti, ore, giorni, mesi o anni, a seconda dell’unità più grande. L’utilizzo causerà l’aggiornamento dei template all’inizio di ogni nuovo minuto. L’utilizzo causerà l’aggiornamento dei template all’inizio di ogni nuovo minuto.
Un’alternativa che potremmo considerare è lavorare sul futuro anziché solo sul tempo passato.
{% set new_datetime = as_datetime('2025-02-07 20:46:13.203634+00:00')%}
{% set time_futuro = as_local(new_datetime) %}
{% set diff_time = time_futuro - now() %}
{{ relative_time(now() - diff_time) }} {# 1 year #}
⬇️ time_since(datetime, precision): Questa funzione converte un oggetto datetime in una stringa più leggibile, rappresentando il tempo trascorso (passato) in termini di secondi, minuti, ore, giorni, mesi e anni. Il parametro ‘precision’ è un numero intero che indica il numero di unità da includere nella stringa risultante. L’ultima unità viene arrotondata.
Ad esempio, con precisione impostata a 1, potrebbe essere restituito ‘2 anni’, mentre con precisione impostata a 2, potrebbe essere restituito ‘1 anno e 11 mesi’. Questa funzione può essere utilizzata anche come filtro. Se il datetime specificato rappresenta un momento nel futuro, viene restituito ‘0 secondi’. Una precisione di 0 restituisce tutte le unità di misura disponibili; il valore predefinito è 1.
{% set new_datetime = as_datetime('2022-4-07 20:46:13.203634+00:00') %}
{{ time_since(new_datetime, 0) }} {# 2 years 27 days 10 hours 45 minutes 40 seconds #}
{{ time_since(new_datetime, 1) }} {# 2 years #}
{{ time_since(new_datetime, 2) }} {# 2 years 27 days #}
{{ time_since(new_datetime, 3) }} {# 2 years 27 days 11 hours #}
{{ time_since(new_datetime) }} {# 2 years #}
{{ time_since(as_datetime('2044-4-07 20:46:13.203634+00:00')) }} {# 2044-04-07 20:46:13.203634+00:00 #}
{{ time_since(states['light.luce_studio'].last_changed, 2) }} {# 6 minutes #}
{{ time_since(states['light.luce_studio'].last_changed, 1) }} {# 5 minutes 44 seconds #}
{{ time_since(states['light.luce_studio'].last_changed) }} {# 6 minutes #}
{{ new_datetime | time_since }} {# 2 years #}
{{ new_datetime | time_since(3) }} {# 2 years 27 days 11 hours #}
Per ottenere una traduzione possiamo utilizzare la funzione replace.
⬇️ time_until(datetime, precision): Questa funzione converte un oggetto datetime in una stringa più leggibile, rappresentando il tempo che manca (futuro) in termini di secondi, minuti, ore, giorni, mesi e anni. Il parametro ‘precision’ è un numero intero che indica il numero di unità da includere nella stringa risultante. L’ultima unità viene arrotondata.
Ad esempio, con precisione impostata a 1, potrebbe essere restituito ‘2 anni’, mentre con precisione impostata a 2, potrebbe essere restituito ‘1 anno e 11 mesi’. Questa funzione può essere utilizzata anche come filtro. Se il datetime specificato rappresenta un momento nel futuro, viene restituito ‘0 secondi’. Una precisione di 0 restituisce tutte le unità di misura disponibili; il valore predefinito è 1.
{% set new_datetime = as_datetime('2034-12-31 20:46:13.203634+00:00') %}
{{ time_until(new_datetime, 0) }} {# 10 years 8 months 3 days 13 hours 5 minutes 6 seconds #}
{{ time_until(new_datetime, 1) }} {# 11 years #}
{{ time_until(new_datetime, 2) }} {# 10 years 8 months #}
{{ time_until(new_datetime, 3) }} {# 10 years 8 months 4 days #}
{{ time_until(new_datetime) }} {# 11 years #}
{{ time_until(as_datetime('2004-4-07 20:46:13.203634+00:00')) }} {# 2004-04-07 20:46:13.203634+00:00 #}
{{ new_datetime | time_until }} {# 11 years #}
{{ new_datetime | time_until(3) }} {# 10 years 8 months 4 days #}
Per ottenere una traduzione possiamo utilizzare la funzione replace.
⬇️ timedelta(): restituisce un oggetto chiamato timedelta, che è utile quando vogliamo aggiungere o sottrarre una quantità di tempo da un oggetto datetime.
Possiamo usare timedelta per rappresentare periodi di tempo specifici, come giorni, ore, minuti, secondi, e così via. I suoi argomenti includono gli stessi valori accettati dalla funzione datetime.timedelta di Python,: days, seconds, microseconds, milliseconds, minutes, hours, weeks.
⬇️ as_timedelta(string): converte una stringa in un oggetto timedelta.
Si aspetta dati nel formato DD HH:MM:SS.uuuuuu, DD HH:MM:SS,uuuuuu, o come specificato da ISO 8601 o dal formato dell’intervallo diurno di PostgreSQL. Questa funzione può essere utilizzata anche come filtro.
⬇️ | timestamp_custom('format_string', local=True, default): è un filtro che converte un timestamp UNIX in un formato di stringa personalizzato.
E’ possibile applicare un valore predefinito per evitare che il filtro generi un errore nel caso in cui la conversione del timestamp UNIX in formato ISO fallisca. In questo modo, se la conversione non è possibile, il filtro restituirà il valore predefinito invece di generare un errore. Inoltre, è possibile specificare se la conversione deve tener conto dell’ora legale.
⬇️ | timestamp_local(default): è un filtro che converte un timestamp UNIX in una stringa nel formato ISO con fuso orario.
E’ possibile applicare un valore predefinito per evitare che il filtro generi un errore nel caso in cui la conversione del timestamp UNIX in formato ISO fallisca. In questo modo, se la conversione non è possibile, il filtro restituirà il valore predefinito invece di generare un errore.
⬇️ | timestamp_utc(default): è un filtro che converte un timestamp UNIX in una stringa nel formato ISO senza fuso orario (UTC).
E’ possibile applicare un valore predefinito per evitare che il filtro generi un errore nel caso in cui la conversione del timestamp UNIX in formato ISO fallisca. In questo modo, se la conversione non è possibile, il filtro restituirà il valore predefinito invece di generare un errore.
Un oggetto JSON è una collezione di coppie chiave-valore racchiuse tra parentesi graffe {}. Le chiavi sono sempre stringhe, mentre i valori possono essere stringhe, numeri, booleani, array, oggetti JSON annidati o null. La sintassi per definire un oggetto JSON in Jinja2 è identica a quella di un dizionario ma le stringhe devono essere racchiuse tra virgolette doppie ", non tra virgolette singole '.
Dettaglio
⬇️ | to_json: è un filtro che prendere un oggetto (come un dizionario, una lista, una tupla, ecc.) e lo converte in una stringa JSON valida.
Semplifica notevolmente la formattazione di una stringa JSON, specialmente quando si tratta di gestire caratteri speciali e escape di caratteri. Questo filtro si occupa automaticamente di codificare correttamente i caratteri speciali all’interno della stringa JSON, garantendo che il risultato sia correttamente formattato e pronto per essere utilizzato.
Accetta argomenti booleani aggiuntivi:
pretty_print: Questo argomento, se impostato su True, formatta il JSON con un rientro di 2 spazi per renderlo più leggibile dall’uomo. Ciò significa che il JSON risultante sarà formattato con una struttura indentata, facilitando la lettura e la comprensione. Se pretty_print è False o non specificato, il JSON verrà restituito senza alcuna formattazione aggiuntiva.
sort_keys: Questo argomento, se impostato su True, ordina le chiavi dell’oggetto JSON in ordine alfabetico. Ciò garantisce che la stringa JSON risultante sia coerente per lo stesso input, indipendentemente dall’ordine in cui sono state definite le chiavi nell’oggetto originale. Se sort_keys è False o non specificato, le chiavi verranno mantenute nell’ordine in cui sono state definite nell’oggetto originale.ù
ensure_ascii=True: Assicura che tutti i caratteri non ASCII vengano convertiti in sequenze di escape Unicode nella stringa JSON risultante.
⬇️ | from_json: è un filtro che prendere una stringa JSONe lo converte in un ogetto equivalente.
Una volta che la stringa JSON è stata deserializzata in un oggetto utilizzando il filtro, è possibile utilizzare i dati all’interno. Ad esempio, si potrebbe assegnare l’oggetto deserializzato a una variabile e accedere ai suoi attributi o elementi come si farebbe con qualsiasi altro oggetto.
{% set stringa_json = '{"nome": "Marco", "età": 36}' %}
{% set ogetto = stringa_json | from_json %}
{{ ogetto }} {# {'nome': 'Marco', 'età': 36} #}
{{ ogetto.nome }} {# Marco #}
{{ ogetto['nome'] }} {# Marco #}
Versione
⬇️ version(): restituisce un oggetto AwesomeVersion per il valore fornito tra parentesi. Questo oggetto consente di eseguire confronti tra versioni.
È anche disponibile come filtro, e può essere utilizzato direttamente su una stringa per convertirla in un oggetto AwesomeVersion.
⬇️ issues(): restituisce un elenco di tutti i problemi aperti, rappresentati come una mappatura di tuple che associa il dominio e issue_id all’oggetto problema corrispondente.
È possibile calcolare la distanza in chilometri e determinare quale entità è più vicina a una zona specifica, coordinata, casa o entità.
⬇️ distance(): consente di misurare la distanza in chilometri.
Se viene passata solo una posizione, Home Assistant calcolerà la distanza dalla posizione di casa.
{{ distance(123.45, 123.45) }} {# cordinata distanza da casa es. 11964.533873 #}
{{ distance('device_tracker.motorola_edge_40') }} {# entità distanza da casa es. 5.547777 #}
{{ distance('device_tracker.motorola_edge_40') }} {# entità distanza da casa es. 5.547777 #}
{{ distance('zone.lavoro_marco') }} {# zona distanza da casa 15.535477 #}
{{ distance('person.marco') }} {# person distanza da casa 5.547777 #}
{{ distance(states.device_tracker.motorola_edge_40) }} {# ogetto di stato distanza da casa es. 5.547777 #}
Se viene specificata un’altra posizione, verrà considerata come punto di riferimento per il calcolo della distanza.
{{ distance(123.45, 123.45, 'device_tracker.motorola_edge_40') }} {# entità distanza da cordinata es. 11964.533873 #}
{{ distance('device_tracker.motorola_edge_40', 'device_tracker.samsung_s21') }} {# distanza tra due entità es. 0.011454 #}
{{ distance('person.marco', 'device_tracker.samsung_s21') }} {# distanza tra due entità es. 0.011454 #}
⬇️ closest(): consente di trovare l’entità più vicina.
Questa funzione restituisce un oggetto di stato e può essere utilizzata anche come filtro.
Se viene passata solo una posizione, troveranno l’entità più vicina alla posizione dell’Home Assistant.
{{ closest(states) }} {# tra tutte le entità (ogetti di stato) #}
{{ closest(states).name }} {# tra tutte le entità (ogetti di stato, name) #}
{{ closest(states.device_tracker) }} {# per un dominio specifico (ogetti di stato) #}
{{ closest(states.device_tracker).name }} {# per un dominio specifico (ogetti di stato, name) #}
{{ closest('group.famiglia') }} {# entità di un gruppo #}
{{ closest(expand('group.famiglia')).name }} {# entità di un gruppo, name #}
{{ closest(states.group.famiglia) }} {# entità di un gruppo #}
{{ closest(states.group.famiglia).state }} {# entità di un gruppo, state #}
{{ 'group.famiglia' | closest }} {# esempio filtro #}
Se viene specificata un’altra posizione, verrà considerata come punto di riferimento per il calcolo della distanza.
{{ closest(23.456, 23.456, 'group.famiglia') }} {# tra cordinata e gruppo #}
{{ closest(23.456, 23.456, 'group.famiglia').name }} {# tra cordinata e gruppo, name #}
{{ closest('zone.lavoro', 'group.famiglia') }} {# tra zona(entità) e gruppo #}
{{ closest('zone.lavoro', 'group.famiglia').name }} {# tra zona(entità) e gruppo, name #}
{{ closest(states.zone.lavoro, 'group.famiglia') }} {# tra zona(ogetto di stato) e gruppo #}
{{ closest(states.zone.lavoro, states).name }} {# tra zona(ogetto di stato) e gruppo, name #}
{{ 'group.famiglia' | closest(states.zone.lavoro) }} {# esempio filtro #}
È possibile specificare una lista di entità da controllare per la loro vicinanza.Poiché l’ultimo argomento ha un valore implicito expande, può accettare qualsiasi sequenza iterabile di stati o ID di entità ed espandere i gruppi per includere tutte le entità pertinenti nella verifica della vicinanza.
{{ closest(['group.famiglia', states.device_tracker]) }} {# gruppo e dominio distanti da casa #}
{{ closest(23.456, 23.456, ['group.famiglia', states.device_tracker]) }} {# gruppo e dominio distanti da cordinate #}
{{ closest(states.zone.lavoro, ['group.famiglia', states.device_tracker]) {# gruppo e dominio distanti da entità #}
{{ ['group.famiglia', states.device_tracker] | closest }} {# esempio filtro da casa#}
{{ ['group.famiglia', states.device_tracker] | closest(23.456, 23.456) }} {# esempio filtro #}
Funzioni numeriche e filtri
Le funzioni numeriche e i filtri generano un errore se l’input non è un numero valido, facoltativamente è possibile specificare un valore di default che verrà invece restituito.
⬇️ is_number: restituisce True se l’input è un numero, altrimenti restituisce False.
È da notare che la funzione analizza un valore booleano True e restituisce True. Tuttavia, se viene passata la stringa "True", verrà interpretata come False.
⬇️ float: verrà convertito l’input in un numero decimale. E’ possibile usarlo sia come funzione che come filtro.
In entrambi i casi, verrà convertito l’input in un float. Se la conversione fallisce, verrà restituito il default specificato; tuttavia, se il default non è specificato e la conversione non riesce, verrà generato un errore.
{{ float(5) }} {# 5.0 #}
{{ float("non_numero") }} {# Template error #}
{{ float(5, default="Numero non valido!") }} {# 5.0 #}
{{ float('non numero', default="Numero non valido!") }} {# Numero non valido! #}
{{ states('sensor.0x00158d0006f78450_illuminance_lux') | float(0) }} {# filtro con default #}
{{ float(states('sensor.0x00158d0006f78450_illuminance_lux'), 0 ) }} {# funzione con default #}
⬇️ int: verrà convertito l’input in un numero intero. E’ possibile usarlo sia come funzione che come filtro.
In entrambi i casi, verrà convertito l’input in un int. Se la conversione fallisce, verrà restituito il default specificato; tuttavia, se il default non è specificato e la conversione non riesce, verrà generato un errore.
{{ int(5) }} {# 5 #}
{{ int("non_numero") }} {# Template error #}
{{ int(5, default="Numero non valido!") }} {# 5 #}
{{ int('non numero', default="Numero non valido!") }} {# Numero non valido! #}
{{ states('sensor.0x00158d0006f78450_illuminance_lux') | int(0) }} {# filtro con default #}
{{ int(states('sensor.0x00158d0006f78450_illuminance_lux'), 0 ) }} {# funzione con default #}
⬇️ bool(value, default): converte il valore in un valore booleano (vero o falso).
Se il valore non rientra in nessuna delle categorie elencate, la funzione restituirà il valore predefinito specificato. Se non viene specificato un valore predefinito, verrà generato un errore.
Come float e int, la funzione bool ha una forma di filtro.
L’uso di none come valore predefinito è particolarmente utile in combinazione con il filtro “if” immediato, poiché può gestire tutti e tre i casi possibili in una sola riga.
{{ bool('errato', none) }} {# Non Boolean #}
{% if bool('errato', none) %}
Valore bool
{% else %}
Valore non Boolean
{% endif %}
{# Valore non Boolean #}
⬇️ log(value, base, default): calcola il logaritmo dell’input.
Se il valore base o value non può essere convertito in un float, la funzione restituirà il valore default specificato.
Se la base viene omessa, viene utilizzata per default la costante matematica e, approssimativamente uguale a 2.71828.
Questa funzione può essere utilizzata anche come filtro.
⬇️ average([x, y, ...], default): restituisce il valore medio della sequenza di una sequenza.
Se la lista è vuota o contiene valori non numerici, restituisce il valore predefinito. Se il valore predefinito è omesso e la lista è vuota o contiene valori non numerici, genera un errore.
Questa funzione può anche essere utilizzata come filtro.
⬇️ median([x, y, ...], default): restituisce il valore centrale o la media dei due valori centrali, a seconda se la sequenza è ordinata o meno.
Se la lista è vuota o contiene valori non numerici, restituisce il valore predefinito. Se il valore predefinito è omesso e la lista è vuota o contiene valori non numerici, genera un errore.
Questa funzione può anche essere utilizzata come filtro.
I dati grezzi, o dati non elaborati, sono dati che non sono stati processati, filtrati o trasformati in alcun modo, sono la forma originale dei dati, talvolta rappresentati in un formato base come byte o bit, senza alcuna interpretazione o struttura applicata. Queste funzioni vengono utilizzate per elaborare i valori grezzi in formato di byte in valori di tipo Python nativo o viceversa e fanno uso della libreria struct di Python 3.
⬇️ pack(value, format_string): è utilizzata per convertire un tipo di dato nativo in un oggetto di tipo byte.
Questo processo avviene utilizzando un modello di formattazione specificato dalla stringa format_string, che determina come il valore deve essere convertito in byte. Se si verifica un errore durante il processo di conversione o se la stringa di formato non è valida, la funzione restituirà None per indicare che si è verificato un problema.
Questa funzione può anche essere utilizzata come filtro.
esempio con formato di conversione come intero
{{ pack(42, 'i') }} {# b'*\x00\x00\x00' #}
{{ 42 | pack('i') }} {# b'*\x00\x00\x00' #}
⬇️ unpack(value, format_string, offset=0): è utilizzato per convertire un oggetto di tipo byte in un oggetto di tipo Python nativo.
Quando si utilizza, è possibile specificare un modello di formattazione (format_string) che indica come interpretare i byte e un parametro opzionale offset che indica da quale posizione all’interno dell’oggetto di byte iniziare a leggere i dati. È importante notare che se si verifica un errore durante il processo di conversione o se il modello di formattazione non è valido, la funzione restituirà None.
Questa funzione può anche essere utilizzata come filtro.
{% set a = 42 | pack(">I") %}
{{ unpack(a, '>I') }} {# 42 #}
{{ unpack(a, '>H', offset=1) }} {# 0 #}
{{ a | unpack(">I") }} {# 42 #}
{{ a | unpack(">H", offset=1) }} {# 0 #}
Conclusione
Spero che questo titanico lavoro di Marco Picardo ti possa essere d’aiuto quanto merita in quanto è stata davvero un’impresa colossale per lui stendere questo testo e credo che possa essere davvero utile sia per imparare che ai più esperti come riferimento rapido durante la stesura del proprio codice.
Un sentito ringraziamento a Marco da parte mia (Henrik) per l’impegno, la dedizione e la pignoleria con cui ha steso questo articolo, che intende anche tenere aggiornato man mano che escono nuove funzioni con gli aggiornamenti di Home Assistant!
Ti va di darmi una mano?
Il contenuto di questo sito è completamente gratuito senza pubblicità invasive e il fine non è certo guadagnare …ma mantenere un sito ha un costo. Se ti va di darmi una mano per sostenere le spese o ti va di sostenere questo progetto hai le seguenti modalità:
Donazione con Paypal:
Regalami un caffè su Buymeacoffee:
Effettua i tuoi acquisti Amazon a partire da QUESTO LINK (o tramite i prodotti sotto)
Acquistare i tuoi prodotti Shelly usando QUESTO LINK
Effettuare i tuoi acquisti AliExpress usando QUESTO LINK
Shelly Pro EM 50A è un misuratore di elettricità monofase altamente preciso a due canali che può essere montato su una guida DIN; È inoltre dotato di un interru... altre informazioni
Shelly BLU Wall Switch 4 Stand Alone è un interruttore di controllo Bluetooth intelligente che può essere utilizzato come dispositivo autonomo senza dover esser... altre informazioni
Shelly Plus 2PM è un interruttore a relè intelligente con 2 canali, fino a 16 A (max 18 A), e due misuratori di consumo; Può funzionare in due modalità: modalit... altre informazioni
Shelly Plus 1 è un interruttore intelligente senza fili (16A) progettato per automatizzare gli elettrodomestici e le altre apparecchiature elettriche a casa o a... altre informazioni
Dimensioni ridotte, prestazioni massime: Shelly Plus 1 Mini Gen3 è il più piccolo interruttore a relè offrendo prestazioni di controllo intelligente senza compr... altre informazioni
⚙️ Shelly 1 Plus interruttore wifi smart ⚙️ il più piccolo e potente interruttore wifi del mondo ⚙️ 220 volt e da 24 volt a 240 volt DC con contatto pulito
【Dimensioni super minuscole】 Le sue dimensioni compatte ne consentono l'installazione in varie scatole di montaggio, incluso il più piccolo standard europeo. 【C... altre informazioni
Shelly Dimmer 2 è un dimmer Wi-Fi ideale per regolare l'intensità della luce e misurare con precisione il consumo energetico; Può essere inserito in qualsiasi i... altre informazioni
Shelly Pro 4PM è un relè monofase, a 4 canali, installabile su guida DIN e dotato di connettività LAN, Wi-Fi e Bluetooth, che supporta carichi fino a 16 A per c... altre informazioni
Immane lavoro, molto interessante ed esaustivo per chi vuole approfondire.
Personalmente mi mancava una guida così dettagliata sull’argomento !
Grazie Henrik
Su questo sito vengono usati i cookie per darti la migliore esperienza utente ricordando le tue preferenze tra visite diverse. Cliccando "Accetta tutti" accetterai l'uso di TUTTI i cookie. Puoi comunque visitare la pagina "Impostazioni cookie" per dare un consenso più granulare.
This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary cookies are absolutely essential for the website to function properly. These cookies ensure basic functionalities and security features of the website, anonymously.
Cookie
Durata
Descrizione
cookielawinfo-checkbox-analytics
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional
11 months
The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy
11 months
The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.
Functional cookies help to perform certain functionalities like sharing the content of the website on social media platforms, collect feedbacks, and other third-party features.
Performance cookies are used to understand and analyze the key performance indexes of the website which helps in delivering a better user experience for the visitors.
Analytical cookies are used to understand how visitors interact with the website. These cookies help provide information on metrics the number of visitors, bounce rate, traffic source, etc.
Advertisement cookies are used to provide visitors with relevant ads and marketing campaigns. These cookies track visitors across websites and collect information to provide customized ads.
Immane lavoro, molto interessante ed esaustivo per chi vuole approfondire.
Personalmente mi mancava una guida così dettagliata sull’argomento !
Grazie Henrik