Migrera skript till Python 3.13 i Workiva

Workiva-skript och slut på stöd för Python 3.9

För att framtidssäkra dina automatiseringar har Workiva introducerat stöd för Python 3.13 , tillsammans med en inställning på skriptnivå som låter dig välja körtidsversion för varje skript. Den här guiden förklarar hur man går säkert från 3.9 till 3.13, vad som ska testas och hur man implementerar ändringar med minimal störning.

Fram till oktober 2025 förlitade sig Workiva Scripting på den officiella Python 3.9-utgåvan från Python Software Foundation; denna nådde slutet av sin livscykel i oktober 2025 och får följaktligen inte längre säkerhetsuppdateringar eller buggfixar.

Som svar på detta har Workiva Scripting övergått till att använda Amazon Linux 2023 (AL2023) image, som tillhandahåller sina egna versioner och stöd för både Python 3.9 och Python 3.13. Denna förändring säkerställer att Python 3.9 får löpande säkerhetsuppdateringar och underhåll genom Amazons uppdateringscykel, även om den uppströmsversionen av Python inte längre patchas av öppen källkod-communityn.

Till följd av denna övergång kommer Workiva Scripting att fortsätta stödja säker körning av skript på Python 3.9 fram till oktober 2027 .

Vem borde tänka på den här migrationen? Alla som för närvarande kör Workiva Scripting-automatiseringar på Python 3.9 – oavsett om de utlöses manuellt, från kedjor eller via integrerade automatiseringar.

Vad händer om jag inte gör någonting? Dina skript kommer att förbli säkra genom AL2023-patchar fram till oktober 2027, men vi rekommenderar att du migrerar till Python 3.13 eftersom det är den nyare körningsmiljön som stöds.

För mer bakgrundsinformation om tidslinjer för slutet av livscykeln och versioner som stöds, läs den officiella Webbsida för Python-utgivningsstatus.

Hur Workiva stöder denna förändring

Workiva lanserade en uppdatering för att ge utvecklare kontroll över vilken Python-körningstid deras skript använder. Den här uppdateringen medförde följande ändringar:

Stöd för Python 3.13: Alla nya skript använder nu Python 3.13 som standard, den senaste stabila versionen.
Runtime-migrering per skript: Befintliga Python 3.9-skript kan migreras till Python 3.13. Efter att ett skript har migrerats till Python 3.13 kan det inte ändras tillbaka till Python 3.9.
Bakåtkompatibilitet: Alla befintliga skript fortsätter att använda Python 3.9 tills du uppdaterar dem.
Redigerare och API-stöd: Du kan ställa in eller uppdatera körtiden direkt i Workiva Script Editor eller via Scripting API.

Detta säkerställer att du kan migrera enligt din egen tidslinje, testa säkert och bara byta produktionsskript när du är säker på att de är redo.

Tidslinje för denna övergång

För att hjälpa dig planera, här är lanseringsschemat:

Python 3.13 tillgänglig i Workiva (september 2025): Befintliga Python 3.9-skript kan migreras till Python 3.13 med hjälp av Scripting API eller Scripting Editor. Nya skript använder Python 3.13.
Python 3.9 slutar fungera (oktober 2025): Officiellt stöd för Python-communityn upphör. Workiva kommer att fortsätta stödjas via AL2023 till och med oktober 2027, men migrering rekommenderas starkt.
Oktober 2027: Workiva planerar att avsluta stödet för Python 3.9 i oktober 2027, varefter alla skript kommer att köras på Python 3.13.

Att göra övergången

Du bör börja testa skript på Python 3.13 så snart som möjligt, samtidigt som produktionen fortsätter på endast 3.9 tills du har verifierat att de körs korrekt på 3.13. När du är bekväm med att använda Python 3.13, byt över dina produktionsskript till Python 3.13-körtiden utan dröjsmål.

Byta ett skript till Python 3.13

Vårt rekommenderade utrullningsmönster: skapa en kopia, uppdatera versionen, testa och marknadsför sedan. Detta minimerar produktionsrisken och låter dig behålla körhistorik om du behöver det.

Steg 1 — Gör en kopia

Gör en kopia av ditt produktionsskript i Workiva.
Kopian kommer att ställas in på Python 3.13.

Steg 2 — Testa och anpassa texten

Kör kopian i en säker/testkontext.
Åtgärda eventuella ändringar som inte fungerar (se ” Vanliga problem och åtgärder ”).
Validera resultat, biverkningar och prestanda.

Steg 3 — Ändra till 3.13 (två alternativ)

Alternativ A — Detta sparar produktionshistoriken

Skjut den uppdaterade koden från kopian tillbaka till det ursprungliga skriptet genom att kopiera och klistra in.
Ändra det ursprungliga skriptets körtid till Python 3.13 .
Kör om dina tester och återuppta sedan normal schemaläggning/utlösare på originalet.
(Valfritt) Arkivera eller ta bort kopian.

Alternativ B — Detta sparar inte produktionshistoriken

Ändra produktionsutlösaren (det vill säga kedjeutlösaren) så att den pekar från originalskriptet till kopieringsskriptet .
Kopian blir det nya produktionsskriptet (som körs på Python 3.13 ).
(Valfritt) Arkivera eller ta bort originalet.

Uppmaning till handling: Oavsett vilket alternativ du väljer, flytta alla dina aktiva skript till Python 3.13 senast oktober 2027.

Uppdatera Python runtime-versionen

Använda skript-API:et

Innan du börjar, se till att ditt API-tillstånd inkluderar omfången script:read och script:write . För instruktioner om hur du skapar eller uppdaterar ett API-tillstånd, se Workiva API-konfiguration .

Bestäm skriptets körtid.

GET /scripts/{scriptId} Auktorisering: Bearer {token} X-version: 2026-01-01

Kontrollera värdet för runtime i svaret.

Uppdatera skriptet till Python 3.13.

PATCH /scripts/{scriptId} Auktorisering: Bearer {token} X-version: 2026-01-01 Innehållstyp: application/json [{
 "op": "replace",
 "path": "/runtime",
 "value": "python3.13"
}]

Att ändra körtiden återskapar inte automatiskt skriptets beroendepaket. Om skriptet innehåller en requirements.txt- källa, initiera beroendegenerering efter att du har uppdaterat körningsmiljön och vänta tills åtgärden är klar innan du kör skriptet. Skript utan requirements.txt kräver inte beroendegenerering.

För mer information, se dessa Workiva-utvecklarsidor:

Exempel: Ändra och läsa Python-körtidsversionen

Följande exempelkod hämtar ett skripts aktuella körningstid, migrerar det till Python 3.13 och regenererar dess beroendepaket med hjälp av Scripting API.

 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={ "Innehållstyp": "application/x-www-form-urlencoded;charset=UTF-8", "X-Version": API_VERSION, }, data={ "client_id": client_id, "client_secret": client_secret, "grant_type":   Behöver du en klient för att komma åt klienten? Be ... "client_credentials", }, timeout=30, ) response.raise_for_status() return { "Auktorisering": f"Bärare {response.json() ['access_token']}", "X-Version": API_VERSION, } def läsversion(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"Python-version för '{script ['name']}' script: " f"{['runtime']script .replace('python', '')}" ) def ändra_till_python_313(script_id, headers): response = requests.patch( f"{SCRIPTS_API_URL}/{script_id}", headers={ **headers, "Innehållstyp":      Typ:     Innehållstyp:   ** ** "application/json"[{
 "op": "replace",
 "path": "/runtime",
 "value": "python3.13",
 }], }, json= , timeout=30, ) response.raise_for_status() script = response.json() print( f"Python-version för '{script ['name']}' skript ändrat till: " f"{['runtime']script .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" för source i 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 {"avslutad", "misslyckades", "avbruten"}: break time.sleep( int( operation_response.headers.get("Försök igen", "5")) ) if operation  ["status"]!= "avslutad": raise RuntimeError( f"Beroendegenerering avslutad med status " 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("Beroenden har genererats.") else: print("Ingen requirements.txt-källa hittades; beroendegenerering hoppades över.")

Använda skriptredigeraren

Med skriptredigeraren kan du konfigurera körtiden direkt i användargränssnittet. För ett befintligt skript som använder Python 3.9, använd Egenskaper → Runtime-version för att migrera det till Python 3.13. Efter att skriptet har sparats kan det inte ändras tillbaka till Python 3.9.

Så här uppdaterar du ett skript i redigeraren:

Öppna skriptet i skriptredigeraren .
Gå till egenskapspanelen till höger.
Under Runtime-version väljer du Python 3.13 från rullgardinsmenyn.
Spara dina ändringar.
Kör skriptet i en säker/testmiljö innan du uppgraderar till produktion.

Tips

Se till att alla tredjepartspaket i dina skript är kompatibla med Python 3.13.
Uppdatera alla fästa paketversioner i din requirements.txt -fil (till exempel, till skillnad från i Python 3.9, behövs inte requests==2.28 i 3.13).
Läs den officiella Python-dokumentationen för detaljer om de viktigaste ändringarna i Python-versionerna 3.10 , 3.11 , 3.12 och 3.13 , inklusive:
- Strukturell mönstermatchning, uppdateringar av f-strängar, förbättrade felmeddelanden
- Betydande prestandaförbättringar (funktionsanrop, strängoperationer, minneshantering, JSON-serialisering/deserialisering)
- Utfasning av paket och vissa paketparametrar har tagits bort ( cgi , cgitb , distutils , etc. har föråldrats; parametern asyncio "loop" har tagits bort)

Vanliga migreringsproblem och lösningar vid övergång från 3.9 till 3.13

Här är några vanliga problem som du kan stöta på när du flyttar skript från Python 3.9 till 3.13, tillsammans med förslag på lösningar för dem:

Tredjepartsbibliotek: Vissa paket kanske ännu inte stöder Python 3.13.
- Åtgärd: Uppgradera till den senaste kompatibla versionen eller ersätt den med en alternativ version. Testa alla fastställda krav noggrant. Du kan kontrollera stöd för dina bibliotek på pyreadiness.org/3.13 och läsa hjälpartikeln " Skriptbibliotek och beroenden som stöds " för mer information.
Version av förfrågningsbibliotek: Förfrågningsbiblioteket är det vanligaste tredjepartsbiblioteket i Workiva Scripting. I tidiga versioner av Python 3.9 kommer skript att brytas med förfrågningar version 2.30.0 eller senare. När du har migrerat till Python 3.13 kan du använda de senaste versionerna av förfrågningar utan problem.
Python 3.13 har skillnader i hantering av strängar och bytes: Striktare typkontroller kan avslöja dolda problem.
- Åtgärd: Kontrollera kod som blandar str och byte och säkerställ explicit kodning/avkodning.
Datum- och tidszonsbeteende: Python 3.13 har skillnader i zoneinfo- biblioteket och striktare parsning.
- Åtgärd: Testa all datum-/tidslogik, särskilt formatering och tidszonkonverteringar.
JSON-serialisering: Vissa objekt kan misslyckas med att serialiseras på grund av strängare regler.
- Åtgärd: Se till att anpassade objekt konverteras före json.dumps , eller använd standardkodare.
Föråldrade API:er: Vissa Python stdlib- funktioner (till exempel asyncio.get_event_loop , distutils och vissa lokala API:er) som var föråldrade i Python 3.9 har tagits bort.
- Åtgärd: Uppdatera koden för att använda stödda alternativ.
Prestandaförändringar: Loopar och asynkrona uppgifter kan bete sig annorlunda.
- Åtgärd: Kör belastningstester på kritiska sökvägar; uppdatera samtidighetslogiken om det behövs.

Tips: Testa alltid kopior av dina produktionsskript först. Korrigeringar som tillämpas i en kontrollerad testmiljö minskar risken för produktionsproblem.

Nyheter i Python 3.13

Här är några viktiga ändringar för Python 3.13:

Förbättrad interaktiv tolk: Redigering av flera rader, färger och färgade spårningar.
Experimentellt fritt trådat byggläge: Tillåter verkliga parallella trådar (ingen GIL) på vissa plattformar.
Experimentell JIT: Tidigt förarbete för prestandaförbättringar.
Bättre felsökningsverktyg: locals() -mutationer fungerar nu med väldefinierad semantik.
Ny minnesallokerare: Modifierad mimalloc inkluderad och aktiverad som standard om den stöds.
Mindre filer: Docsträngar tar bort inledande blanksteg, vilket minskar minnesanvändningen och .pyc-filstorlekar.
Ny dbm-backend: Använder dbm.sqlite3 som standard.
Plattformsuppdateringar: macOS minst 10.13, iOS/Android Tier 3, WASI Tier 2.
Förbättringar av skrivning: Standardinställningar för skrivning, förträngning, skrivskyddade objekt och anteckningar om utfasning.
Borttagningar: Föråldrade moduler har tagits bort (till exempel cgi , telnetlib , imghdr , lib2to3 , etc.).

För fullständiga versionsinformation, se Python.orgs " Nyheter i Python 3.13 ".

Om du vill granska de specifika ändringarna som infördes mellan 3.9 och 3.13, se:

Vanliga frågor och svar

F: Måste jag migrera alla mina skript direkt?
Nej, det gör jag inte. Du kan börja testa skript på Python 3.13 nu och fortsätta produktionen på 3.9 medan du gör det. Alla skript måste migreras till Python 3.13 före oktober 2027 .

F: Bröts mina befintliga skript automatiskt när Python 3.9 nådde slutet av sin livscykel?
Nej, det gör jag inte. Workiva Scripting använder sig av Amazons Python 3.9-version under Amazon Linux 2023 (AL2023), som fortsätter att få säkerhetsuppdateringar fram till oktober 2027. Dina skript påverkas inte av det officiella slutet av Python 3.9.

F: Kan jag testa skript på 3.13 medan produktionen fortsätter på 3.9?
Ja. Skapa en kopia av ditt skript för testning – kopian ställs automatiskt in för att köras på Python 3.13. Åtgärda eventuella problem i texten innan du flyttar den till produktion. För att undvika att förlora kompatibilitet, behåll separata versioner – en för 3.9 och en för 3.13 – så att du enkelt kan växla mellan dem vid behov.

F: Har skriptredigeraren stöd för att ändra körtiden?
Ja. Du kan ställa in ett skripts Python-körtid direkt i skriptredigeraren – öppna skriptet, gå till panelen Egenskaper och välj versionen under Körtidsversion.

F: Var kan jag få mer information om biblioteksstöd?
Kontrollera pyreadiness.org/3.13 och "Skriptbibliotek och beroenden som stöds"Workiva hjälpartikel."

F: Vad händer med mina historiska kördata om jag byter skript?
Det beror på. Om du skriver över det ursprungliga skriptet behåller du körningshistoriken. Om du pekar utlösare till en kopia kommer originalets körhistorik att finnas kvar med det gamla skriptet.

F: Vad händer om jag inte migrerar senast oktober 2027?
Dina skript kommer automatiskt att övergå till Python 3.13 efter oktober 2027, då Workiva upphör med stödet för att köra skript på Python 3.9 under AL2023. För att undvika störningar bör du testa och migrera skript till Python 3.13 i god tid före oktober 2027.

F: Behöver jag ändra mina kedjor eller integrerade automationer när jag migrerar?
Nej, det gör jag inte. Dina kedjor och integrerade automatiseringar kommer att fortsätta köras som förväntat, så länge de underliggande skripten uppdateras till Python 3.13. Det viktigaste steget är att se till att själva skriptet migreras.

F: Kan jag återställa ett skript från Python 3.13 till 3.9 om problem uppstår?
Nej, det gör jag inte. När ett skript är inställt på Python 3.13 kan dess körtid inte återställas till Python 3.9. Om du vill ha en reserv, behåll en separat kopia av skriptet på Python 3.9 – behåll en version på 3.9 och en annan på 3.13 – så att du kan återgå till 3.9-kopian om problem uppstår under testningen.

Workiva supportcenter