foxygit / RPA-Remisser Log in
commits tags

/README.md · 25.16 KB

raw

RPA-verktyg

Generellt verktyg för webbläsar-automation byggt på Playwright, med en webbaserad flödesbyggare där du klickar ihop steg (gå till URL, klicka, skriv i fält, extrahera data, ladda ner filer, loopa över listor, spara till JSON/CSV, köra egna Python-script, ...) istället för att skriva kod för varje ny automation.

Byggt för fall där inloggningen kräver manuell interaktion (BankID, 2FA, captcha) och därför inte kan helautomatiseras säkert: verktyget öppnar en synlig webbläsare, du loggar in en gång manuellt, och sessionen sparas i en persistent profil så du slipper göra om det varje körning.

Repot innehåller dels det generella ramverket (webui + rpa/-paketet), dels ett fristående exempel på en färdig automation byggd med det (hämtning av egenremisser från personal.1177.se) - se sist i dokumentet.

För en fullständig referens över alla stegtyper, villkor, variabel- interpolering, loop-typer och felsökningsverktyg, se docs/wiki.html (öppna lokalt i en webbläsare).

Setup

Linux/macOS: använd medföljande skript, som skapar .venv, installerar paket + Playwright Chromium, och sen aktiverar venv åt dig vid start:

./install.sh   # engångssetup
./start.sh     # aktiverar venv, startar webui:t på http://127.0.0.1:8765
./start.sh main  # aktiverar venv, kör main.py (fristående 1177-exempel)

Windows: använd medföljande skript (engångssetup – skapar .venv, installerar paket + Playwright Chromium):

powershell -ExecutionPolicy Bypass -File .\install_win.ps1

(eller dubbelklicka install_win.bat). Starta sedan:

.venv\Scripts\Activate.ps1
python run_webui.py     # webui:t på http://127.0.0.1:8765
python run_webui.py --force   # om en gammal instans redan kör: ta över porten
python main.py          # fristående 1177-exempel

Manuellt, om du hellre gör stegen själv:

python -m venv .venv
.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python -m playwright install chromium

Webb-UI:t är en färdigbyggd React-app (incheckad i webui/static/), så python run_webui.py funkar utan Node. Node behövs bara om du vill ändra UI:t – se "Utveckla webb-UI:t" nedan.

Webb-UI: node-canvas

python run_webui.py → öppna http://127.0.0.1:8765 Flödet är en graf på ett node-canvas (pan/zoom/minikarta): varje nod är ett steg, och du drar kablar mellan noderna för att bestämma körordningen. if-noder har ett utgångshandtag per gren (case0, case1, … + else); loop-noder har each (per varv) och done – koppla kroppens sista nod tillbaka till loopens in. Nodens in-handtag sitter upptill, utgångarna nedtill. Dra en nod för att flytta den (positionen sparas med flödet). "Autoplacera" lägger ut grafen uppifrån och ner.

  • Vänsterpalett – dra en stegtyp till canvasen (eller dubbelklicka) för att

    lägga till en lös nod; koppla sedan ihop den. Typ-dropdownen i noden finns kvar för att byta typ på plats. Fliken Block = återanvändbara flödesdelar (se nedan).

  • Subflöden & flikar – flikraden ovanför canvasen visar Main + en flik per

    lokal subgraf (+ skapar, dubbelklick döper om). En call_flow-nod kör ett annat flöde eller en lokal subgraf som ett steg, med explicit in-/ut-mappning (target = flödesnamn eller #<subflow-id>). Varje subflow-flik har en "Kör denna flik"-knapp för att testa den isolerat.

  • ⚙-menyn (uppe till höger) – Nytt/Ta bort flöde, Exportera, close-mode,

    körningsinställningar (headless/skip_browser/viewport…), Kör-parametrar / indata, språk, Inspektera fönster, Wiki.

  • Block – markera noder på canvasen → "💾 Spara markering som block" → de

    dyker upp i palettens Block-flik och kan dras in i andra flöden. Sparas i data/blocks/. Medföljande exempel ligger i repo-mappen blocks/.

  • Kör-parametrar / indata – deklarera vilka variabler flödet förväntar sig

    vid körning (⚙ → "Kör-parametrar / indata"): namn, etikett, standardvärde, ev. Alternativ (komma-separerat → rullista i stället för textfält). Har flödet minst en deklarerad indata öppnas en dialog automatiskt vid "Kör flöde" – fyll i värden, eller välj ett sparat värde-set i rullistan ("💾 Spara som set" sparar aktuella värden under ett namn, t.ex. "Produktion"/"Test"). Extra ad-hoc-variabler kan läggas till där också. Värdena når stegen som vanliga {variabel}. Seten sparas i flödet, följer med vid export (--set NAMN / --var namn=värde på kommandoraden) och kan väljas via MCP:s run_flow(..., input_set="...").

Desktop-automation (Windows)

Utöver webbläsaren kan flöden styra Windows-appar – både vanliga appar via Windows UI Automation och bild-/koordinatklick för appar utan tillgänglighets-API. Stegen heter desktop_* och syns i "Desktop (Windows)"-kategorin i nod-editorn. Kräver Windows + paketen i requirements.txt (pywinauto, pyautogui, opencv-python – installeras bara på Windows). Ett desktop_*-steg på annan plattform ger ett tydligt fel, inte en krasch.

  • Starta app (desktop_launch) – kör t.ex. notepad.exe. För paketerade

    appar (Win11:s Notepad, Kalkylatorn m.fl.) har den startade processen inget eget fönster – fyll i fältet Fönstertitel (regex) så hittas rätt fönster ändå. Anslut till fönster (desktop_connect) attachar till en app som redan körs.

  • Klicka / Skriv i / Läs kontroll – hitta en kontroll via

    name (synlig text), auto_id (AutomationId), control_type (Button/Edit…) eller class_name. window (titel-regex) begränsar till ett visst fönster; tomt = "aktuellt" fönster (senast startat/anslutet).

  • Tryck tangenter (desktop_press_key) – pywinauto-syntax: ^s = Ctrl+S,

    {ENTER}, %{F4} …

  • Klicka på bild / Vänta på bild – matcha en referensbild på skärmen

    (pyautogui + OpenCV). I steget finns en 📷 Fånga-knapp som öppnar ett overlay – dra en ruta över det du vill fånga, så sparas bilden i data/desktop_images/ och fylls i automatiskt. Från terminalen: python -m rpa.desktop_capture [namn].

  • Klicka på koordinat (desktop_click_xy) – absoluta skärmkoordinater.

Appar som ett flöde startat med desktop_launch städas enligt samma close-mode-val som webbläsaren (stäng alltid / håll öppen vid fel / håll alltid öppen).

Ett flöde utan webbläsarsteg (bara desktop_* och variabelsteg) startar ingen webbläsare – det upptäcks automatiskt. Vill du tvinga bort den (t.ex. under utveckling) finns "Starta ingen webbläsare" i ⚙ Inställningar (skip_browser); ett webbläsarsteg med den påslagen ger då ett tydligt fel.

Hitta rätt selectors: ⚙ → Inspektera fönster i webui:t (välj ett körande fönster → lista dess kontroller → "Nytt desktop_click" fyller i by/value åt dig). Eller från terminalen:

python -m rpa.desktop_inspect                  # listar synliga toppfönster
python -m rpa.desktop_inspect "Anteckningar"   # dumpar kontroll-identifierare

OCR, frågor & uppslag

För arbetsflöden som blandar webb, skrivbord och skannade dokument:

  • ocr_read – OCR (Windows: winocr + pymupdf) av en inskannad PDF, ett

    fönster, ett skärmområde eller en bildfil → variabel. pattern (regex) eller near (värdet bredvid en etikett) plockar ut just det du vill ha. Kräver att svenskt OCR-språk är installerat i Windows.

  • prompt – pausa och visa en ruta: bekräfta (OK/Avbryt), fråga efter ett

    värde, eller visa variabler redigerbara så användaren kan rätta OCR-fel innan de skrivs vidare.

  • lookup – slå upp en nyckel ({grupp}|{spec}) i en JSON-map (inläst

    variabel eller fil i data/exports/). merge_json skriver tillbaka en nyckel – för kom-ihåg-tabeller. read_url läser aktuell URL (+ regex). stop avbryter med ett meddelande.

Ett komplett exempel som använder allt detta finns i docs/salma-elvis.md (remissregistrering Sälma → ELVIS).

AI: bygg och kör flöden med en AI-agent

Verktyget kan drivas av en AI på två sätt. Båda använder samma stegschema (rpa/schema.py) som webui:t, så en AI bara kan de steg som faktiskt finns.

1. "Föreslå ändringar" i webui:t (beskriv i text → flöde)

I sidopanelen finns en ruta "AI-assistent". Skriv på svenska vad flödet ska göra (t.ex. "gå till example.com, vänta på inloggning, lista alla länkar och spara som CSV") och klicka Föreslå ändringar. Förslaget läggs in i editorn i osparat läge – granska, och tryck sedan Spara / Kör flöde som vanligt.

Kräver en Claude-nyckel: sätt miljövariabeln ANTHROPIC_API_KEY (eller kör ant auth login) innan du startar run_webui.py. Modell styrs av RPA_ASSIST_MODEL (default claude-opus-5).

2. MCP-server (Claude Code / Claude Desktop styr verktyget)

rpa/mcp_server.py exponerar verktyget som en MCP-server: en AI-agent kan lista/hämta/skapa/redigera/ta bort flöden, validera dem, samt köra dem och läsa körloggen.

Registrera i Claude Code (byt ut sökvägen mot din .venv-python):

claude mcp add rpa -- C:\Users\<du>\Desktop\proj\RPA-Remisser\.venv\Scripts\python.exe -m rpa.mcp_server

Eller i Claude Desktop (%AppData%\Claude\claude_desktop_config.json):

{
  "mcpServers": {
    "rpa": {
      "command": "C:\\Users\\<du>\\Desktop\\proj\\RPA-Remisser\\.venv\\Scripts\\python.exe",
      "args": ["-m", "rpa.mcp_server"]
    }
  }
}

MCP-servern körs från projektmappen (den hittar rpa/-paketet via -m). Fråga sen agenten t.ex. "lista mina RPA-flöden", "skapa ett flöde som ...", "kör flödet X och visa loggen".

OBS: MCP-servern och webui:t delar samma Chromium-profilmapp (data/browser_profile/) – bara en körning åt gången. Stäng ett körande flöde i webui:t innan du kör ett via MCP, och tvärtom.

Kom igång: hitta rätt selectors för en ny sida

Rekommenderat sätt: Playwright Codegen. Den öppnar en webbläsare + ett inspector-fönster; klicka runt manuellt på sidan du vill automatisera så genereras exakta selectors åt dig i realtid – inget gissningsarbete:

python -m rpa.codegen <url>

Den återanvänder samma profil (data/browser_profile/) som webui:t, så en giltig inloggningssession följer med. Stäng ev. körande flöde i webui:t först (en Chromium-profilmapp kan bara användas av en process åt gången). Använd de genererade text-/CSS-värdena direkt i webui:ts steg (t.ex. "Klicka", "Skriv i textfält", "Lista poster").

Alternativ (mer manuellt): python -m rpa.discover loggar in och låter dig, för varje sida du manuellt navigerar till, spara en HTML-dump + skärmdump i data/discover/ genom att trycka Enter i terminalen - bra när du hellre vill läsa igenom den faktiska HTML-strukturen själv.

python -m rpa.discover

Webb-UI för att bygga och köra flöden

python run_webui.py

Öppna sedan http://127.0.0.1:8765 i webbläsaren. Servern lyssnar bara på 127.0.0.1 (inte nätverket) eftersom den styr en riktig webbläsare mot din inloggade session.

I UI:t bygger du ett flöde som en lista av steg:

  • Gå till URL – navigerar (t.ex. https://example.com/)
  • Vänta (sekunder) – fast paus
  • Vänta på att sidan laddas – väntar på domcontentloaded
  • Gå tillbaka – webbläsarens "bakåt" (historik), t.ex. efter att ha

    klickat in på en post från en lista, för att fortsätta en loop över listan

  • Vänta på inloggning (BankID) – pausar tills du godkänt inloggningen manuellt
  • Vänta på element – pausar tills ett element via text/CSS/roll finns/syns
  • Klicka – hittar ett element via text/CSS/roll och klickar
  • Skriv i textfält – hittar ett fält via text/CSS/roll och skriver in text
  • Tryck tangent – trycker en tangent (t.ex. Enter) på ett element eller,

    om inget element anges, på hela sidan

  • Välj i dropdown – väljer ett alternativ (synlig text) i en <select>
  • Kryssa checkbox/radio – kryssar i eller ur en checkbox/radioknapp
  • Läs text till variabel – läser textinnehållet i ett element och sparar

    det under ett variabelnamn

  • Sätt variabel – sätter en variabel till ett fast textvärde
  • Öka variabel – ökar en heltalsvariabel med ett steg (default 1,

    negativt värde minskar); saknad/icke-numerisk variabel räknas som 0. Lägg sist i en loop för att numrera filer: {räknare} blir 1, 2, 3 …

  • Nollställ variabel – tar bort en variabel; nästa "Lägg till i lista" /

    "Ladda ner bilaga" skapar den på nytt tom. Lägg först i en loop för att nollställa en samlar-lista per varv.

  • Lägg till i lista – lägger till ett värde i en listvariabel (skapas

    automatiskt vid behov); värdet kan antingen läsas från ett element (samma via/text/CSS/roll som "Läs text till variabel") eller vara ett fast värde. Praktiskt inuti en loop för att samla ihop en lista av poster.

  • Spara variabel (JSON/CSV) – sparar en variabel till data/exports/.

    Format gissas från filändelsen (.json/.csv) om inget anges explicit. "Läge" = "append" lägger till i en befintlig fil istället för att skriva över den.

  • Läs in variabel (JSON/CSV) – läser tillbaka en tidigare sparad fil

    från data/exports/ till en variabel, t.ex. för att fortsätta bygga på en lista i en senare körning.

  • Kör Python-script – kör ett separat Python-script (sökväg relativt

    projektroten eller absolut), loggar dess stdout/stderr i körloggen och kan spara dess stdout som en variabel (tolkas som JSON om möjligt, annars som text). Flödet stoppas om scriptet avslutar med felkod. Praktiskt för egen efterbehandling av data som extraherats i flödet.

  • Ta skärmdump – sparar en skärmdump i data/screenshots/ (bra för

    felsökning av flöden)

  • Lista poster – hittar alla element som matchar en CSS-selector och

    sparar dem under ett variabelnamn (t.ex. poster)

  • Om / annars om / annars ("if") – kör bara sina inre steg om ett

    villkor stämmer. Första grenen ("Om") vars villkor är sant körs; fler grenar kan läggas till som "...annars om"; en valfri "...annars (else)"-gren körs om ingen av grenarna matchade. Villkor: "Element finns"/"Element finns inte" (samma via/text/CSS/roll som andra steg) eller "Variabel är lika med"/"är INTE lika med"/"innehåller" (jämför mot en variabels textinnehåll).

  • Hoppa till etikett ("goto") – hoppar till ett annat steg som fått

    samma text i sitt "Etikett"-fält (syns bredvid typ-väljaren på varje steg), framåt eller bakåt. Fungerar bara mellan steg på samma nivå - kan inte hoppa in i eller ut ur en Loop/If-gren. Ett skydd stoppar körningen om för många hopp sker (misstänkt oändlig loop).

  • Loop (för varje post) – itererar över en variabel, på två sätt:
    • Resultat från "Lista poster" (DOM-element): steg inuti loopen kan sätta

      Sökområde = "item" för att bara söka inom aktuell post.

    • En vanlig listvariabel (t.ex. från "Lägg till i lista" eller "Läs in

      variabel", som en tidigare sparad CSV-fil) – då finns varje varvs värde i variabeln "item" (eller det namn du anger i "Variabel för aktuell post"), och kan användas som {item} i ett "Hitta via: text"/"role"-fält i ett steg längre ner (t.ex. "Klicka") för att hitta och interagera med motsvarande rad på sidan.

    • Varvnumret (1, 2, 3 …) finns dessutom alltid i variabeln "index" (eller

      namnet i "Variabel för varvräknare"), oavsett looptyp – användbart som {index} i filnamn.

  • Ladda ner – klickar ett element och sparar filen i data/downloads/
  • Ladda ner bilaga – hittar en <a> i (eller under) elementet och sparar

    filen i data/downloads/. Har länken en riktig href hämtas filen direkt via webbläsarsessionen (ingen ny flik/skrivardialog); är det en javascript:-länk klickas den och en nedladdning/ny flik fångas. var lägger sökvägen i en lista – loopa bilagerader (list + Loop, scope=item, value=a[href]) för att få 0, 1 eller flera filer.

  • Fånga PDF (skriv ut-knapp) – för "Skriv ut"-knappar som öppnar

    webbläsarens skrivardialog i stället för att ladda ner en fil. Neutraliserar window.print, klickar ev. triggern och fångar PDF:en via ett PDF-nätverkssvar, en inbäddad PDF i sidan, eller Chrome "printToPDF" av sidan. Sparar i data/downloads/ och kan lägga sökvägen i en variabel.

Vid fel: stanna / fortsätt (per steg)

Bredvid etikettfältet på varje steg väljer du vad som händer om steget misslyckas eller får timeout: "Vid fel: stanna" (default – avbryter körningen) eller "Vid fel: fortsätt" – felet loggas och nästa steg körs ändå. Använd det för steg som är "hit or miss", t.ex. ett Vänta på element eller Klicka som bara ibland dyker upp. På en Loop/If gäller valet hela blocket. (Ladda ner, Ladda ner bilaga och Fånga PDF fortsätter redan alltid vid fel.)

Variabler i textfält ({variabelnamn})

Fält av typen "Hitta via: text/role" samt de literala textfälten i "Skriv i textfält", "Sätt variabel" och "Lägg till i lista" stöder {variabelnamn} – ersätts med variabelns aktuella textvärde vid körning. Fungerar inte i CSS-selectors, filnamn eller URL:er. Praktiskt tillsammans med "Loop" över en vanlig lista (se ovan) för att hitta rätt rad på sidan utifrån ett tidigare sparat värde.

Ett typiskt flöde: Gå till URL → Vänta på inloggning → Klicka → Lista poster → Loop { Läs text till variabel, Lägg till i lista, Ladda ner } → Spara variabel som CSV.

Flöden sparas som JSON i data/flows/<namn>.json – redigerbara även för hand om du vill. "Kör flöde" sparar automatiskt och kör sedan i en synlig webbläsare, med live-logg i sidan.

Bredvid "Kör flöde" väljer du vad som ska hända med webbläsaren efteråt:

  • Stäng webbläsaren – stängs alltid direkt när flödet är klart (standard).
  • Håll öppen vid fel – stängs bara om flödet lyckades; vid fel hålls den

    öppen så du kan se vad som klickats fel.

  • Håll alltid öppen – stängs aldrig automatiskt.

När webbläsaren hålls öppen visas en "Stäng webbläsare"-knapp i sidan – klicka på den när du är klar med att inspektera.

Se variablernas innehåll

Under körloggen finns en "Variabler"-panel som fylls i när flödet är klart (eller vid fel). Klicka på ett variabelnamn för att expandera och se dess faktiska innehåll (text visas rakt av, listor/objekt som JSON) – praktiskt för att felsöka t.ex. vad "Lägg till i lista" faktiskt samlade ihop innan det sparades till CSV.

Felsöka en körning (trace)

Varje körning spelar automatiskt in en Playwright-trace – skärmdumpar, DOM-snapshots och nätverk för varje steg – och sparar den i data/traces/<run_id>.zip. När körningen är klar dyker en "Visa trace"-knapp upp i sidan; klicka på den för att öppna Playwrights Trace Viewer i ett eget fönster och steg-för-steg se exakt vad som klickades och var det gick fel.

Samma sak från terminalen:

python -m rpa.show_trace          # senaste sparade trace
python -m rpa.show_trace <run_id> # en specifik körning

Inställningar

"⚙ Inställningar" i headern öppnar en dialog med körningsinställningar, sparade tillsammans med flödet (så de följer med vid export – se nedan):

  • Headless – kör utan synligt webbläsarfönster. Kräver en redan giltig

    inloggningssession (BankID/2FA går inte att godkänna i ett headless-fönster).

  • Fönsterbredd/-höjd – webbläsarens viewport-storlek.
  • Locale – t.ex. sv-SE (standard).
  • Slow motion – millisekunder paus mellan varje åtgärd, praktiskt för att

    kunna följa med ögat när man felsöker ett flöde.

  • Skrivbordsnotis – visas när körningen är klar (kräver plyer, redan i

    requirements.txt).

Exportera som fristående script

"Export as script" i headern laddar ner en .py-fil som kör exakt samma flöde (steg + inställningar) utan webui:t – bra för schemaläggning via Windows Task Scheduler av ett flöde byggt i UI:t, inte bara main.py. Scriptet importerar rpa-paketet och anropar samma run_flow()-motor som webui:t, så beteendet blir identiskt.

python mitt_flode.py                    # kör med flödets sparade inställningar
python mitt_flode.py --headless          # tvinga headless oavsett sparad inställning
python mitt_flode.py --close-mode never  # håll webbläsaren öppen efteråt

Kräver att scriptet körs där rpa-paketet är importerbart (från projektroten, eller med rpa/-mappen kopierad bredvid).

Persistent inloggning

Sessionen sparas i data/browser_profile/ (persistent Chromium-profil), så om den fortfarande är giltig nästa gång körs behöver du inte logga in igen. Det gäller oavsett om flödet körs via webui:t, python -m rpa.codegen, eller ett eget script byggt på rpa/browser.py.

rpa/auth.py innehåller ett generellt mönster för att vänta ut en manuell inloggning: wait_for_login(page, timeout_s, indicators=...) pollar sidan tills någon textsträng i indicators (fri textmatchning) syns, eller ger upp efter en timeout. I webui:t sätts detta direkt i steget "Vänta på inloggning" (fältet för inloggad-text, komma-separerat) - alltså per flöde/sajt, utan att röra Python-kod. Lämnas fältet tomt faller det tillbaka på standardvärdet config.LOGGED_IN_INDICATORS, som du kan anpassa tillsammans med config.START_URL om du kör via main.py/eget script istället för webui:t.

Schemaläggning

Kör manuellt vid behov, eller exportera ett flöde som ett fristående script (se "Exportera som fristående script" ovan) och schemalägg det via Windows Task Scheduler. Tänk på att manuell inloggning (BankID/2FA) krävs varje gång sessionen i data/browser_profile/ har gått ut, så helt obevakad körning fungerar bara så länge sessionen är giltig.

Utveckla webb-UI:t

UI:t ligger i webui/frontend/ (Vite + React + TypeScript, node-canvasen är React Flow). Kräver Node 20+.

cd webui\frontend
npm install
npm run dev      # dev-server på :5173, proxar /api till run_webui.py på :8765

Kör python run_webui.py i ett annat fönster samtidigt. Efter ändringar:

npm run build    # bygger till ../static/
npm test         # vitest (graf-round-trip)

Checka in webui/static/ – den är själva UI:t som run_webui.py serverar.

Stegtyperna kommer från GET /api/step-schema (dvs. rpa/schema.py), så nya steg behöver bara läggas där + i flow_engine.py – UI:t renderar dem automatiskt. Flödet lagras som en nod/kant-graf ({format:"graph", nodes, edges, start, settings, subflows}); gamla {steps}-flöden migreras vid inläsning (rpa/migrate.py) och körs av rpa/graph_engine.py. subflows är lokala namngivna subgrafer som call_flow-noder anropar.

Bygga en egen fristående automation

Utöver webui:ts JSON-flöden går det förstås bra att skriva ett eget Python-script mot samma byggstenar i rpa/:

  • rpa/browser.py – launch_context()/get_page(), den persistenta

    Chromium-profilen.

  • rpa/auth.py – vänta ut manuell inloggning.
  • rpa/config.py – gemensamma sökvägar och sajt-specifika inställningar

    (URL, textindikatorer för inloggning, etc.) - detta är filen du främst anpassar per ny automation.

main.py + rpa/scraper.py + rpa/state.py + rpa/notify.py + rpa/discover.py är ett komplett exempel byggt på detta: hämtning av egenremisser från personal.1177.se, med diff mot förra körningen (state.py) och skrivbordsnotis vid nytt/ändrat (notify.py). Kör det med:

python main.py

Resultat: data/state.json (senaste kända lista), data/downloads/ (nedladdade dokument), skrivbordsnotis + terminalutskrift vid nya/ändrade poster.

Använd det som mall när du bygger en ny fristående automation för en annan sajt - byt ut scraper.pys sid-specifika logik, config.pys START_URL/LOGGED_IN_INDICATORS, och notify.pys meddelandetext. Behöver du inte diff/notis-mönstret alls räcker det oftast med ett flöde i webui:t.

Att tänka på

  • Respektera användarvillkoren för sajten du automatiserar - detta är

    byggt för att hämta din egen personliga information, inte för massuttag eller belastning. Webbläsaren körs synlig och "vanlig" utan bot-detection-kringgång. Lägg gärna in rimliga pauser om du kör ofta.

  • Spara inte data/browser_profile/, data/downloads/, data/traces/,

    data/screenshots/ eller data/exports/ i något delat eller versionshanterat ställe - de kan innehålla inloggningssessioner och personlig/känslig information beroende på vilken sajt du automatiserar (traces och skärmdumpar visar sidans faktiska innehåll steg för steg, och exports kan innehålla data du samlat in från sidan). data/ ligger redan i .gitignore.

  • "Kör Python-script" kör vad som helst du pekar ut, med samma rättigheter

    som webui-processen - bara för egna, betrodda script, inte för att köra kod du inte litar på.