Migrazione degli script a Python 3.13 in Workiva

Workiva Scripting e la fine del supporto a Python 3.9

Per garantire che le tue automazioni siano a prova di futuro, Workiva ha introdotto il supporto per Python 3.13 , insieme a un’impostazione a livello di script che ti consente di scegliere la versione di runtime per ogni script. Questa guida spiega come passare in modo sicuro dalla versione 3.9 alla 3.13, quali sono i test da effettuare e come introdurre le modifiche con il minimo disturbo.

Fino al ottobre 2025 , Workiva Scripting si basava sulla versione ufficiale di Python 3.9 rilasciata dalla Python Software Foundation ; tale versione ha raggiunto la fine del ciclo di vita nell’ottobre 2025 e, di conseguenza, non riceve più aggiornamenti di sicurezza né correzioni di bug.

In risposta a ciò, Workiva Scripting è passato all'utilizzo dell'immagine Amazon Linux 2023 (AL2023) , che fornisce build dedicate e supporto sia per Python 3.9 che per Python 3.13. Questa modifica garantisce che Python 3.9 continui a ricevere patch di sicurezza e manutenzione attraverso il ciclo di aggiornamento di Amazon, anche se la versione upstream di Python non viene più aggiornata dalla comunità open source.

A seguito di questa transizione, Workiva Scripting continuerà a supportare l'esecuzione sicura degli script su Python 3.9 fino al ottobre 2027 .

Chi dovrebbe pensare a questa migrazione? Chiunque stia eseguendo le automazioni di Workiva Scripting su Python 3.9- sia che vengano attivate manualmente, da catene o tramite automazioni integrate.

Cosa succede se non faccio nulla? I tuoi script rimarranno protetti grazie alle patch AL2023 fino a ottobre 2027, ma ti consigliamo di passare a Python 3.13, poiché è la versione più recente supportata.

Per ulteriori informazioni sulle tempistiche di fine vita e sulle versioni supportate, consulta la pagina web ufficiale sullo stato dei rilasci di Python.

Come Workiva supporta questo cambiamento

Workiva ha rilasciato un aggiornamento per consentire agli sviluppatori di scegliere il runtime Python da utilizzare per i propri script. Questo aggiornamento ha introdotto le seguenti modifiche:

Supporto per Python 3.13: Tutti i nuovi script utilizzano ora Python 3.13, l'ultima versione stabile, come impostazione predefinita.
Migrazione in fase di esecuzione per script: Gli script esistenti in Python 3.9 possono essere migrati a Python 3.13. Una volta che uno script è stato migrato a Python 3.13, non è più possibile riportarlo a Python 3.9.
Compatibilità con le versioni precedenti: Tutti gli script esistenti continueranno a utilizzare Python 3.9 fino a quando non li aggiornerai.
Editor e supporto API: È possibile impostare o aggiornare il runtime direttamente nell'editor di script di Workiva o tramite l'API di scripting.

In questo modo potrai migrare secondo le tue tempistiche, fare test sicuri e cambiare gli script di produzione solo quando sei sicuro che siano pronti.

Tempistica per questo passaggio

Per aiutarti a pianificare, ecco il calendario di lancio:

Python 3.13 disponibile in Workiva (settembre 2025): Gli script esistenti scritti in Python 3.9 possono essere migrati a Python 3.13 utilizzando l'API di scripting o l'editor di scripting. I nuovi script utilizzano Python 3.13.
Fine del ciclo di vita di Python 3.9 (ottobre 2025): Cessa il supporto ufficiale da parte della comunità Python. Workiva continuerà a fornire assistenza tramite AL2023 fino a ottobre 2027, ma si raccomanda vivamente di procedere alla migrazione.
Ottobre 2027: Workiva prevede di interrompere il supporto per Python 3.9 nell'ottobre 2027; da quel momento in poi, tutti gli script funzioneranno con Python 3.13.

Affrontare la transizione

Dovresti iniziare a testare gli script su Python 3.13 il prima possibile, mantenendo l'ambiente di produzione su 3.9 solo fino a quando non avrai verificato che funzionino correttamente su 3.13. Una volta che ti sentirai a tuo agio nell'uso di Python 3.13, passa subito i tuoi script di produzione al runtime Python 3.13.

Passare uno script a Python 3.13

Lo schema di rollout consigliato: creare una copia, aggiornare la versione, testare e promuovere. Questo riduce al minimo i rischi per la produzione e ti permette di conservare la cronologia delle esecuzioni se ne hai bisogno.

Passo 1 - Crea una copia

In Workiva, crea una copia dello script di produzione.
La versione verrà impostata su Python 3.13.

Passo 2 - Testare e adattare la copia

Esegui la copia in un contesto sicuro/di prova.
Correggi eventuali modifiche di rottura (vedi "Problemi comuni e correzioni").
Convalida gli output, gli effetti collaterali e le prestazioni.

Passo 3 - Passa a 3.13 (due opzioni)

Opzione A - In questo modo si manterrà la cronologia dei cicli di produzione

Riporta il codice aggiornato dalla copia allo script originale tramite copia-e-incolla.
Cambia il runtime dello script originale in Python 3.13.
Esegui nuovamente i test, quindi riprendi la normale programmazione/trigger sull'originale.
(Opzionale) Archivia o ritira la copia.

Opzione B - Questo non manterrà la cronologia dei cicli di produzione

Cambia l'innesco di produzione (cioè l'innesco Chains) in modo che punti dallo script originale allo script copia.
La copia diventa il nuovo script di produzione (in esecuzione su Python 3.13).
(Facoltativo) Archivia o ritira l'originale.

Invito all'azione: Qualunque opzione scegliate, trasferite tutti i vostri script attivi su Python 3.13 entro ottobre 2027.

Aggiornare la versione runtime di Python

Usare l'API di scripting

Prima di iniziare, assicurati che la tua autorizzazione API includa gli ambiti script:read e script:write . Per istruzioni su come creare o aggiornare un'autorizzazione API, consultare Configurazione dell'API di Workiva .

Determina il tempo di esecuzione dello script.
```
GET /scripts/{scriptId} Authorization: Bearer {token} X-Version: 2026-01-01
```
Controlla il valore di runtime nella risposta.

Aggiorna lo script a Python 3.13.

PATCH /scripts/{scriptId} Autorizzazione: Bearer {token} X-Version: 2026-01-01 Content-Type: application/json [{ "op": "replace", "path": "/runtime", "value": "python3.13" }]

La modifica del runtime non comporta la rigenerazione automatica del pacchetto delle dipendenze dello script. Se lo script contiene una fonte del tipo requirements.txt , avviare la generazione delle dipendenze dopo aver aggiornato il runtime e attendere il completamento dell'operazione prima di eseguire lo script. Gli script che non contengono file " " e "requirements.txt" non richiedono la generazione delle dipendenze.

Per ulteriori dettagli, consulta queste pagine dedicate agli sviluppatori di Workiva:

Esempio: Modifica e lettura della versione runtime di Python

Il codice di esempio riportato di seguito recupera il runtime corrente di uno script, lo migra a Python 3.13 e rigenera il relativo pacchetto di dipendenze utilizzando l'API di scripting.

import os import time import requests CLIENT_ID = os.environ["CLIENT_ID"] CLIENT_SECRET = os.environ["CLIENT_SECRET"] SCRIPT_ID = os.environ["SCRIPT_ID"] API_VERSION = "2026-01-01" API_BASE_URL = "https://api.app.wdesk.com" SCRIPTS_API_URL = f"{API_BASE_URL}/scripts" AUTH_URL = f"{API_BASE_URL}/oauth2/token" def get_auth_headers(client_id, client_secret): response = requests.post( AUTH_URL, headers={ "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8", "X-Version": API_VERSION, }, data={ "client_id": client_id, "client_secret": client_secret, "grant_type": "client_credentials", }, timeout=30, ) response.raise_for_status() return { "Authorization": f"Bearer {response.json()['access_token']}", "X-Version": API_VERSION, } def read_version(script_id, headers): response = requests.get( f"{SCRIPTS_API_URL}/{script_id}", headers=headers, timeout=30, ) response.raise_for_status() script = response.json() print( f"Versione Python per lo script '{script['name']}': " f"{script['runtime'].replace('python', '')}" ) def change_to_python_313(script_id, headers): response = requests.patch( f"{SCRIPTS_API_URL}/{script_id}", headers={ **headers, "Content-Type": "application/json", }, json=[{ "op": "replace", "path": "/runtime", "value": "python3.13", }], timeout=30, ) response.raise_for_status() script = response.json() print( f"La versione di Python per lo script '{script['name']}' è stata modificata in: " f"{script['runtime'].replace('python', '')}" ) def has_requirements(script_id, headers): response = requests.get( f"{SCRIPTS_API_URL}/{script_id}/sources", headers=headers, timeout=30, ) response.raise_for_status() return any( source["path"] == "requirements.txt" for source in response.json()["data"] ) def regenerate_dependencies(script_id, headers): response = requests.post( f"{SCRIPTS_API_URL}/{script_id}/dependencies/generation", headers=headers, timeout=30, ) response.raise_for_status() operation_url = response.json()["operationLocation"] while True: operation_response = requests.get( operation_url, headers=headers, timeout=30, ) operation_response.raise_for_status() operation = operation_response.json() if operation["status"] in {"completed", "failed", "cancelled"}: break time.sleep( int(operation_response.headers.get("Retry-After", "5")) ) if operation["status"] != "completed": raise RuntimeError( f"La generazione delle dipendenze si è conclusa con lo stato " f"{operation['status']}: {operation}" ) headers = get_auth_headers(CLIENT_ID, CLIENT_SECRET) read_version(SCRIPT_ID, headers) change_to_python_313(SCRIPT_ID, headers) if has_requirements(SCRIPT_ID, headers): regenerate_dependencies(SCRIPT_ID, headers) print("Dipendenze rigenerate con successo.") else: print("Nessun file source requirements.txt trovato; generazione delle dipendenze saltata.")

Utilizzo dell'editor di scripting

Con lo Scripting Editor è possibile configurare l'ambiente di esecuzione direttamente nell'interfaccia utente. Per uno script esistente che utilizza Python 3.9, utilizzare Proprietà → Versione di runtime per migrarlo a Python 3.13. Una volta salvato, lo script non può più essere riportato alla versione Python 3.9.

Per aggiornare uno script nell'Editor:

Apri lo script nell'Editor di script .
Vai al pannello Properties sulla destra.
In Runtime Version, seleziona Python 3.13 dal menu a tendina.
Salva le modifiche.
Esegui lo script in un ambiente sicuro/test prima di promuoverlo alla produzione.

Suggerimenti

Assicurati che i pacchetti di terze parti presenti nei tuoi script siano compatibili con Python 3.13.
Aggiorna le versioni dei pacchetti nel tuo file requirements.txt (ad esempio, a differenza di Python 3.9, requests==2.28 non è necessario in 3.13).
Leggi la documentazione ufficiale di Python per maggiori dettagli sulle principali modifiche apportate alle versioni di Python 3.10, 3.11, 3.12, e 3.13, tra cui:
- Corrispondenza dei modelli strutturali, aggiornamenti delle f-stringhe, messaggi di errore migliorati
- Miglioramenti significativi delle prestazioni (chiamate di funzione, operazioni sulle stringhe, gestione della memoria, serializzazione/deserializzazione JSON)
- Deprecazione di pacchetti e rimozione di alcuni parametri dei pacchetti (cgi, cgitb, distutils, ecc. sono stati deprecati; il parametro asyncio "loop" è stato rimosso)

Problemi comuni di migrazione e correzioni nel passaggio dalla 3.9 alla 3.13

Ecco alcuni problemi comuni che potresti incontrare quando sposti gli script da Python 3.9 a 3.13, insieme alle soluzioni suggerite per risolverli:

Librerie di terze parti: Alcuni pacchetti potrebbero non supportare ancora Python 3.13.
- Correggi: Aggiorna all'ultima versione compatibile o sostituiscila con una alternativa. Verifica con attenzione tutti i requisiti che ti sono stati assegnati. Puoi verificare il supporto per le tue librerie su pyreadiness.org/3.13 e consultare l'articolo della guida "Librerie di scripting e dipendenze supportate" per maggiori informazioni.
Versione della libreria richiesta: La libreria di è la libreria di terze parti più diffusa in Workiva Scripting. Nelle prime versioni di Python 3.9, gli script si rompono con le richieste di versione 2.30.0 o più recente. Una volta migrato a Python 3.13, potrai utilizzare le ultime versioni delle richieste di senza problemi.
Python 3.13 presenta alcune differenze nella gestione delle stringhe e dei byte: I controlli di tipo più rigorosi possono far emergere problemi nascosti.
- Fix: Controlla il codice che mescola str e byte e assicura una codifica/decodifica esplicita.
Comportamento di date, ora e fuso orario: Python 3.13 presenta alcune differenze nella libreria zoneinfo e un'analisi sintattica più rigorosa. Fix: Verifica tutta la logica di data/ora, in particolare la formattazione e le conversioni di fuso orario.
Serializzazione JSON: Alcuni oggetti potrebbero non essere serializzati a causa di regole più rigide.
- Correzione: Assicurati che gli oggetti personalizzati siano convertiti prima di json.dumps, oppure usa gli encoder predefiniti.
API obsolete: Alcune funzioni Python della libreria standard (ad esempio, asyncio.get_event_loop , distutils e alcune API relative alle impostazioni locali) dichiarate obsolete in Python 3.9 sono state rimosse. Fix: Aggiornare il codice per utilizzare le alternative supportate.
Modifiche alle prestazioni: I cicli e le attività asincrone potrebbero comportarsi in modo diverso.
- Correggi: Esegui i test di carico sui percorsi critici; aggiorna la logica della concorrenza se necessario.

Suggerimento: Testa sempre prima le copie degli script di produzione. Le correzioni applicate in un ambiente di test controllato riducono il rischio di problemi in produzione.

Cosa c'è di nuovo in Python 3.13

Ecco alcune novità di Python 3.13:

Interprete interattivo migliorato: Modifica su più righe, colori e traceback colorati.
Modalità di compilazione sperimentale con thread liberi: Consente l'uso di thread realmente paralleli (senza GIL) su alcune piattaforme.
JIT sperimentale: Primi passi verso il miglioramento delle prestazioni.
Strumenti di debug migliorati: locals() Le mutazioni ora funzionano con una semantica ben definita.
Nuovo allocatore di memoria: . È inclusa una versione modificata di mimalloc, abilitata di default se supportata.
File più piccoli: Le stringhe di documentazione eliminano gli spazi iniziali, riducendo l'utilizzo di memoria e le dimensioni dei file .pyc.
Nuovo backend dbm: Utilizza di default dbm.sqlite3 .
Aggiornamenti della piattaforma: ; macOS versione 10.13 o superiore, iOS/Android Livello 3, WASI Livello 2.
Miglioramenti relativi ai tipi: Impostazioni predefinite dei tipi, restrizioni, elementi di sola lettura e annotazioni di deprecazione.
Rimozioni: Moduli obsoleti rimossi (ad esempio, cgi , telnetlib , imghdr , lib2to3 , ecc.).

Per le note di rilascio complete, consulta la pagina di Python.org "Cosa c'è di nuovo in Python 3.13".

Se vuoi rivedere le modifiche specifiche introdotte tra la versione 3.9 e la 3.13, consulta:

Domande frequenti

D: Devo migrare subito tutti i miei script?
N. È possibile iniziare fin da ora a testare gli script su Python 3.13, mantenendo l'ambiente di produzione su 3.9 nel frattempo. Tutti gli script devono essere migrati a Python 3.13 entro l' , ottobre 2027 .

D: I miei script esistenti hanno smesso di funzionare automaticamente quando Python 3.9 è giunto al termine del ciclo di vita?
N. Workiva Scripting si basa sulla versione Python 3.9 di Amazon su Amazon Linux 2023 (AL2023), che continuerà a ricevere patch di sicurezza fino a ottobre 2027. I tuoi script non sono interessati dalla fine del ciclo di vita ufficiale di Python 3.9.

D: Posso testare gli script su 3.13 mantenendo la produzione su 3.9?
Sì. Crea una copia del tuo script per eseguire dei test: la copia verrà automaticamente configurata per l'esecuzione su Python 3.13. Correggi eventuali problemi nella copia prima di promuoverla in produzione. Per evitare di perdere la compatibilità, tieni versioni separate, una per la versione 3.9 e una per la 3.13, in modo da poter passare facilmente da una all'altra se necessario.

D: L'Editor di script supporta la modifica del runtime?
Sì. È possibile impostare il runtime Python di uno script direttamente nell'Editor di script: aprire lo script, passare al pannello Proprietà e selezionare la versione nella sezione Versione del runtime.

D: Dove posso trovare maggiori informazioni sul supporto delle librerie?
Controlla pyreadiness.org/3.13 e l'articolo della guida di Workiva "Librerie di scripting e dipendenze supportate".

D: Cosa succede ai dati storici delle mie esecuzioni se cambio script?
Dipende. Se sovrascrivi lo script originale, mantieni la cronologia delle esecuzioni. Se punti i trigger a una copia, la cronologia delle esecuzioni dell'originale rimarrà con il vecchio script.

D: Cosa succede se non effettuo la migrazione entro ottobre 2027?
I tuoi script passeranno automaticamente a Python 3.13 dopo ottobre 2027, quando Workiva interromperà il supporto per l'esecuzione di script su Python 3.9 nell'ambito di AL2023. Per evitare interruzioni, è consigliabile testare e migrare gli script a Python 3.13 con largo anticipo rispetto a ottobre 2027.

D: Devo cambiare le mie Catene o Automazioni integrate durante la migrazione?
N. Le tue catene e le automazioni integrate continueranno a funzionare come previsto, a condizione che gli script sottostanti vengano aggiornati a Python 3.13. Il passo principale è assicurarsi che lo script stesso venga migrato.

D: Posso ripristinare uno script da Python 3.13 a 3.9 se si verificano dei problemi?
N. Una volta che uno script è impostato su Python 3.13, non è più possibile riportarne l'ambiente di esecuzione a Python 3.9. Se vuoi una soluzione di riserva, conserva una copia separata dello script su Python 3.9 — mantieni una versione su 3.9 e un’altra su 3.13 — in modo da poter tornare alla copia 3.9 se dovessero sorgere problemi durante i test.

Centro assistenza di Workiva