Rete

collegati(indirizzo, porta, tempo_massimo = 10, tls = falso)#

Si collega a un programma che ascolta su quella porta.

Restituisce una connessione: invia(testo), ricevi(), ricevi_riga(), chiudi(); aperta dice se il collegamento è ancora attivo. Si parla in testo (UTF-8). Con tls = vero il collegamento è cifrato (per i servizi sicuri); con verifica = falso accetta anche un certificato non riconosciuto (comodo per i TUOI server di prova, meno sicuro).

variabile c = collegati("127.0.0.1", 5000)c.invia("Ciao!")stampa(c.ricevi_riga())

server_tcp(porta, in_rete = falso)#

Apre un server che aspetta collegamenti sulla porta.

Normalmente ascolta solo su questo computer (127.0.0.1). Con in_rete = vero anche gli altri computer della rete di casa possono collegarsi, ma prima l'utente deve dare il permesso. porta = 0 sceglie una porta libera (la leggi in server.porta). Poi server.aspetta_cliente() restituisce una connessione.

variabile server = server_tcp(5000)variabile c = server.aspetta_cliente()

invia_udp(messaggio, indirizzo, porta)#

Manda un breve messaggio UDP a un programma.

indirizzo = "tutti" lo manda a tutti i computer della rete di casa (broadcast). UDP è veloce ma non garantisce che il messaggio arrivi. Restituisce vero.

invia_udp("Chi c'è?", "tutti", 5005)

ricevi_udp(porta, tempo_massimo = 10, in_rete = falso)#

Aspetta un messaggio UDP sulla porta.

Restituisce un dizionario con "messaggio", "mittente" (indirizzo) e "porta" del mittente, oppure nulla se non arriva niente in tempo. Con in_rete = vero ascolta anche i messaggi degli altri computer di casa (serve il permesso dell'utente).

variabile m = ricevi_udp(5005, in_rete = vero)stampa(m["messaggio"])

porta_aperta(indirizzo, porta, tempo_massimo = 3)#

vero se su quell'indirizzo un programma ascolta alla porta.

Serve a controllare i TUOI servizi (il tuo server, la tua stampante...). Controlla una sola porta di un solo indirizzo; fra due controlli verso altri computer passa almeno un secondo.

se porta_aperta("127.0.0.1", 8080) allora stampa("Il mio server è acceso") fine

porta_libera(porta)#

vero se su questo computer la porta non è usata da nessun programma.

Utile prima di aprire un server.

se porta_libera(5000) allora server = server_tcp(5000) fine

indirizzo_di(nome)#

L'indirizzo IP di un sito o di un computer (per esempio "93.184.216.34").

stampa(indirizzo_di("localhost"))

indirizzi_di(nome)#

La lista di tutti gli indirizzi IP (IPv4 e IPv6) di un sito o di un computer.

per ogni ip in indirizzi_di("www.esempio.it") fai stampa(ip) fine

nome_di_indirizzo(indirizzo)#

Il nome del computer che ha quell'indirizzo IP, o nulla se non ha un nome.

stampa(nome_di_indirizzo("127.0.0.1"))

e_indirizzo_ip(testo)#

vero se il testo è un indirizzo IP scritto bene (IPv4 o IPv6).

stampa(e_indirizzo_ip("192.168.1.300"))

info_indirizzo_ip(indirizzo)#

Che tipo di indirizzo è: versione, privato o pubblico, questo computer...

Restituisce un dizionario con "indirizzo", "versione" (4 o 6), "privato" (rete di casa o ufficio), "pubblico" (Internet), "questo_computer" (loopback), "multicast", "riservato", "tipo" (spiegazione in parole).

stampa(info_indirizzo_ip("192.168.1.10")["tipo"])

indirizzo_in_rete(indirizzo, rete)#

vero se l'indirizzo IP fa parte della rete.

stampa(indirizzo_in_rete("192.168.1.42", "192.168.1.0/24"))

info_rete(rete)#

Le informazioni su una rete scritta come "192.168.1.0/24".

Restituisce un dizionario con "rete", "maschera", "prefisso", "broadcast", "primo" e "ultimo" indirizzo utilizzabile, "quanti" (numero di indirizzi per i computer), "privata".

stampa(info_rete("192.168.1.0/24")["quanti"])

certificato_sito(sito, porta = 443, tempo_massimo = 10)#

Le informazioni sul certificato di sicurezza di un sito.

Restituisce un dizionario con "valido" (vero/falso), "problema" (in parole, o nulla), "soggetto", "emittente", "valido_dal", "scadenza" (date), "giorni_rimasti", "nomi" (i siti coperti), "versione_tls". Utile per controllare che i propri siti non abbiano il certificato scaduto.

variabile c = certificato_sito("www.esempio.it")stampa(c["scadenza"])

giorni_scadenza_certificato(sito, porta = 443)#

Quanti giorni mancano alla scadenza del certificato del sito.

Un numero negativo vuol dire che è già scaduto.

se giorni_scadenza_certificato("www.miosito.it") < 15 allora stampa("Rinnova il certificato!") fine

apri_posta(server, utente, password, porta = 993, tls = vero, tempo_massimo = 30)#

Apre una casella di posta (IMAP).

Restituisce una casella_posta con cartelle(), elenco_messaggi(), leggi_messaggio(numero), cerca_messaggi(...), salva_allegati(numero), chiudi(). Legge soltanto: non cancella e non segna i messaggi come letti. La password non viaggia mai senza cifratura e non compare nei messaggi.

variabile posta = apri_posta("imap.esempio.it", "ada@esempio.it", leggi_file("password.txt"))

invia_email_con_allegati(destinatario, oggetto, testo, allegati, mittente, server, porta = 587, utente = nulla, password = nulla, tls = vero, tempo_massimo = 60)#

Invia un'email con dei file.

allegati è il percorso di un file o una lista di percorsi (al massimo 25 MB in tutto). Il resto funziona come invia_email: connessione cifrata, password mai mostrata. Restituisce vero.

invia_email_con_allegati("ada@esempio.it", "Foto", "Eccole!", ["mare.jpg", "monti.jpg"],"leo@esempio.it", "smtp.esempio.it", utente = "leo@esempio.it", password = leggi_file("password.txt"))

apri_ftp(server, utente = "anonymous", password = "", porta = 21, tls = nulla, tempo_massimo = 30)#

Si collega a un server FTP.

Restituisce una connessione_ftp con elenca(), scarica(nome), carica(percorso), chiudi(). Con una password la connessione è cifrata (FTPS); senza cifratura la password si manda solo a questo computer.

variabile ftp = apri_ftp("ftp.esempio.it")stampa(ftp.elenca())

avvia_in_sfondo(comando, cartella = nulla, senza_conferma = falso)#

Avvia un comando e intanto il programma prosegue.

Il comando viene mostrato all'utente, che deve dare il permesso (salvo senza_conferma = vero). Restituisce un processo: leggi_uscita() dà quello che ha scritto finora, aspetta() aspetta che finisca, ferma() lo chiude; in_esecuzione, codice e pid sono proprietà. Funziona su Windows, Linux e macOS (non nell'app Android).

variabile p = avvia_in_sfondo("python3 -m http.server 8000")p.ferma()

sistema_operativo()#

Il nome del sistema: "Windows", "Linux", "macOS" o "Android".

se sistema_operativo() == "Windows" allora stampa("Sei su Windows") fine

memoria_sistema()#

La memoria (RAM) del computer: "totale", "libera", "usata" (in byte), "percentuale_usata", "testo".

Funziona su Windows, Linux, macOS e Android.

stampa(memoria_sistema()["testo"])

spazio_disco(percorso = nulla)#

Lo spazio del disco che contiene percorso (senza: la cartella di casa).

Restituisce "totale", "libero", "usato" (in byte), "percentuale_usata", "testo". Funziona su Windows, Linux, macOS e Android.

se spazio_disco()["libero"] < 1000000000 allora stampa("Meno di 1 GB libero!") fine

info_sistema()#

Un dizionario con le informazioni principali sul computer, su ogni sistema.

Chiavi: "sistema", "versione", "nome_computer", "utente", "processori", "architettura", "memoria_totale", "memoria_libera", "disco_totale", "disco_libero", "cartella_casa", "versione_python".

per ogni chiave in chiavi(info_sistema()) fai stampa(chiave, info_sistema()[chiave]) fine

fai_ping(indirizzo, volte = 1, tempo_massimo = 5)#

Controlla se un computer risponde e quanto è veloce.

Usa il comando ping del sistema verso UN indirizzo (da 1 a 10 volte). Restituisce un dizionario con "raggiungibile" (vero/falso), "millisecondi" (tempo medio, o nulla), "risposte", "inviati".

variabile r = fai_ping("192.168.1.1")stampa(r["millisecondi"], "ms")

osserva_cartella(percorso, sottocartelle = falso)#

Comincia a guardare una cartella per vedere i file nuovi o cambiati.

Restituisce un osservatore: novita() dice cosa è cambiato dall'ultima volta, aspetta_novita() aspetta che cambi qualcosa. Le novità sono un dizionario con "nuovi", "modificati", "eliminati".

variabile arrivi = osserva_cartella("Download")stampa(arrivi.aspetta_novita()["nuovi"])

velocita_scaricamento(indirizzo, secondi_massimi = 10)#

Misura quanto è veloce scaricare da quell'indirizzo web.

Scarica il file (senza salvarlo) per al massimo secondi_massimi secondi. Restituisce "byte", "secondi", "megabit_al_secondo", "kilobyte_al_secondo" e "testo" (per

stampa(velocita_scaricamento("https://www.esempio.it/file-di-prova.bin")["testo"])

.chiudi()#

Chiude il collegamento (l'altro programma riceve nulla).

c.chiudi()

.invia(testo, a_capo = vero)#

Manda un testo all'altro programma.

Con a_capo = vero (predefinito) aggiunge "\n" alla fine: così l'altro lo legge con ricevi_riga().

c.invia("Ciao, sono Ada")

.ricevi(tempo_massimo = nulla)#

Il testo arrivato (aspetta finché arriva qualcosa).

Restituisce nulla se passa tempo_massimo secondi senza niente o se l'altro chiude (allora connessione.aperta diventa falso).

variabile arrivato = c.ricevi(5)

.ricevi_riga(tempo_massimo = nulla)#

La prossima riga arrivata (senza "\n").

È il modo più semplice per parlare fra due programmi: uno fa invia(...), l'altro ricevi_riga(). Restituisce nulla a tempo scaduto o se l'altro ha chiuso.

mentre c.aperta fai stampa(c.ricevi_riga()) fine

.aspetta_cliente(tempo_massimo = nulla)#

Aspetta che un programma si colleghi.

Restituisce la connessione con lui, oppure nulla se passano tempo_massimo secondi.

variabile c = server.aspetta_cliente(60)

.chiudi()#

Smette di accettare collegamenti (quelli già aperti restano).

server.chiudi()

.cartelle()#

La lista delle cartelle della casella ("INBOX", "Inviata", "Spam"...).

stampa(posta.cartelle())

.cerca_messaggi(testo = nulla, mittente = nulla, oggetto = nulla, non_letti = falso, cartella = "INBOX", quanti = 50)#

Cerca i messaggi.

Tutte le condizioni date devono valere insieme. Restituisce la stessa lista di elenco_messaggi.

variabile trovati = posta.cerca_messaggi(mittente = "scuola", non_letti = vero)

.chiudi()#

Chiude la casella di posta.

posta.chiudi()

.elenco_messaggi(cartella = "INBOX", quanti = 10)#

Gli ultimi messaggi, dal più nuovo.

Ogni messaggio è un dizionario con "numero", "mittente", "destinatari", "oggetto", "data", "letto", "dimensione". Il "numero" serve a leggi_messaggio.

per ogni m in posta.elenco_messaggi() fai stampa(m["mittente"], "-", m["oggetto"]) fine

.leggi_messaggio(numero, cartella = "INBOX")#

Tutto il messaggio in un dizionario.

Chiavi: "numero", "mittente", "destinatari", "copia", "oggetto", "data", "testo", "html" (o nulla), "allegati" (lista di nomi). Il messaggio non viene segnato come letto.

variabile m = posta.leggi_messaggio(42)stampa(m["testo"])

.salva_allegati(numero, cartella_destinazione = ".", cartella = "INBOX")#

Salva gli allegati del messaggio.

I file già presenti non vengono sovrascritti ("foto (2).jpg"). Restituisce la lista dei percorsi salvati.

stampa(posta.salva_allegati(42, "allegati"))

.carica(percorso, nome = nulla)#

Manda un file di questo computer al server.

Senza nome sul server avrà lo stesso nome. Restituisce vero.

ftp.carica("sito/index.html")

.chiudi()#

Chiude il collegamento con il server FTP.

ftp.chiudi()

.elenca(cartella = nulla)#

La lista dei nomi dei file e delle cartelle sul server.

per ogni nome in ftp.elenca() fai stampa(nome) fine

.scarica(nome, percorso = nulla)#

Scarica un file dal server e restituisce dove l'ha salvato.

Senza percorso il file va nella cartella corrente con lo stesso nome. Il file compare solo quando è completo.

ftp.scarica("listino.pdf", "documenti/listino.pdf")

.aspetta(tempo_massimo = nulla)#

Aspetta che il processo finisca e restituisce il codice (0 = tutto bene).

Se passa tempo_massimo secondi e il processo lavora ancora restituisce nulla.

variabile codice = p.aspetta(30)

.ferma()#

Chiude il processo (e i programmi che ha avviato lui). vero se era ancora acceso.

Si possono chiudere solo i processi avviati dal programma con avvia_in_sfondo.

p.ferma()

.leggi_uscita()#

Il testo scritto dal processo dall'ultima lettura (senza aspettare).

stampa(p.leggi_uscita())

.aspetta_novita(tempo_massimo = nulla, ogni = 1)#

Aspetta che nella cartella cambi qualcosa.

Guarda la cartella ogni ogni secondi; restituisce le novità, o nulla se passa tempo_massimo.

mentre vero fai stampa("Nuovi file:", arrivi.aspetta_novita()["nuovi"]) fine

.novita()#

Cosa è cambiato dall'ultima volta ("nuovi", "modificati", "eliminati"), o nulla se niente.

variabile n = arrivi.novita()se n != nulla allora stampa(n["nuovi"]) fine