Raporty Power BI z Pythona można automatyzować na kilku poziomach: przygotowanie danych, odświeżanie datasetów, eksport raportów do plików, zapis danych do CSV, harmonogram cyklicznych zadań oraz wysyłkę gotowych raportów do odbiorców. Dzięki temu Power BI przestaje być wyłącznie narzędziem do ręcznej analizy, a staje się częścią zautomatyzowanego procesu raportowania.

Python dobrze sprawdza się jako warstwa automatyzacji wokół Power BI. Możesz pobrać dane z plików, API lub bazy danych, oczyścić je w pandas, zapisać źródło dla raportu, wywołać odświeżenie datasetu przez Power BI REST API, poczekać na zakończenie procesu, wyeksportować raport do PDF i wysłać go e-mailem.

W tym artykule znajdziesz praktyczne przykłady: autoryzację do Power BI API, odświeżanie datasetu, sprawdzanie statusu odświeżenia, eksport raportu do PDF, eksport danych do CSV, harmonogram zadań i kompletny pipeline raportowy.

Kiedy warto automatyzować raporty Power BI?

Automatyzacja raportów Power BI ma sens wszędzie tam, gdzie raportowanie jest powtarzalne. Jeśli codziennie lub co tydzień wykonujesz te same czynności, Python może przejąć dużą część pracy.

Najczęstsze scenariusze to:

• codzienne odświeżanie datasetu,
• przygotowanie danych wejściowych przed odświeżeniem,
• eksport raportu do PDF,
• zapis wybranych danych do CSV,
• wysyłka raportu e-mailem,
• uruchamianie raportów o określonej godzinie,
• automatyczne raportowanie dla zarządu lub zespołów,
• kontrola, czy odświeżenie danych zakończyło się sukcesem,
• logowanie błędów w procesie raportowym.

Największa korzyść to powtarzalność. Raport jest generowany według tych samych zasad, o tej samej porze i bez ręcznego klikania.

Wymagania do pracy z Power BI REST API

Do automatyzacji Power BI z Pythona potrzebujesz dostępu do Power BI REST API. W praktyce oznacza to zwykle:

• workspace ID,
• dataset ID,
• report ID,
• tenant ID,
• client ID aplikacji Azure,
• client secret,
• odpowiednie uprawnienia do Power BI API,
• token dostępu OAuth2.

Najwygodniej przechowywać dane dostępowe w zmiennych środowiskowych lub pliku .env, a nie bezpośrednio w kodzie.

Przykładowy plik .env:

ENV
Kopiuj
1
2
3
4
5
6
POWER_BI_TENANT_ID=your-tenant-id
POWER_BI_CLIENT_ID=your-client-id
POWER_BI_CLIENT_SECRET=your-client-secret
POWER_BI_WORKSPACE_ID=your-workspace-id
POWER_BI_DATASET_ID=your-dataset-id
POWER_BI_REPORT_ID=your-report-id

Instalacja potrzebnych bibliotek:

Bash
Kopiuj
1
pip install requests pandas python-dotenv schedule

Pobieranie tokenu dostępu do Power BI API

Do komunikacji z Power BI REST API potrzebny jest token Bearer. Poniższy przykład używa przepływu client credentials.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import os
import requests
from dotenv import load_dotenv

load_dotenv()

def get_power_bi_access_token() -> str:
    """Pobiera token dostępu do Power BI REST API."""
    tenant_id = os.getenv("POWER_BI_TENANT_ID")
    client_id = os.getenv("POWER_BI_CLIENT_ID")
    client_secret = os.getenv("POWER_BI_CLIENT_SECRET")

    if not tenant_id or not client_id or not client_secret:
        raise ValueError("Brakuje danych autoryzacyjnych Power BI w zmiennych środowiskowych.")

    url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"

    data = {
        "grant_type": "client_credentials",
        "client_id": client_id,
        "client_secret": client_secret,
        "scope": "https://analysis.windows.net/powerbi/api/.default"
    }

    response = requests.post(url, data=data, timeout=30)
    response.raise_for_status()

    return response.json()["access_token"]


token = get_power_bi_access_token()
print("Token pobrany poprawnie.")

Token jest później przekazywany w nagłówku Authorization.

Odświeżanie datasetu Power BI z Pythona

Odświeżenie datasetu to jeden z najczęstszych procesów automatyzacji Power BI. Python może wywołać endpoint API, który uruchamia refresh w Power BI Service.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import requests

def refresh_power_bi_dataset(
    workspace_id: str,
    dataset_id: str,
    access_token: str
) -> bool:
    """Uruchamia odświeżenie datasetu w Power BI Service."""
    url = (
        f"https://api.powerbi.com/v1.0/myorg/groups/"
        f"{workspace_id}/datasets/{dataset_id}/refreshes"
    )

    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }

    response = requests.post(url, headers=headers, timeout=30)

    if response.status_code == 202:
        print("Odświeżenie datasetu zostało uruchomione.")
        return True

    print(f"Błąd odświeżania datasetu: {response.status_code}")
    print(response.text)
    return False

Użycie:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
import os

access_token = get_power_bi_access_token()

refresh_power_bi_dataset(
    workspace_id=os.getenv("POWER_BI_WORKSPACE_ID"),
    dataset_id=os.getenv("POWER_BI_DATASET_ID"),
    access_token=access_token
)

Status 202 oznacza, że żądanie zostało przyjęte. Nie oznacza jeszcze, że odświeżenie się zakończyło. Dlatego w praktyce warto sprawdzać status procesu.

Sprawdzanie statusu odświeżenia datasetu

Po uruchomieniu odświeżenia warto pobrać historię refreshy i sprawdzić ostatni status.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import requests

def get_latest_refresh_status(
    workspace_id: str,
    dataset_id: str,
    access_token: str
) -> dict | None:
    """Pobiera status ostatniego odświeżenia datasetu."""
    url = (
        f"https://api.powerbi.com/v1.0/myorg/groups/"
        f"{workspace_id}/datasets/{dataset_id}/refreshes?$top=1"
    )

    headers = {
        "Authorization": f"Bearer {access_token}"
    }

    response = requests.get(url, headers=headers, timeout=30)
    response.raise_for_status()

    refreshes = response.json().get("value", [])

    if not refreshes:
        return None

    return refreshes[0]


status = get_latest_refresh_status(
    workspace_id=os.getenv("POWER_BI_WORKSPACE_ID"),
    dataset_id=os.getenv("POWER_BI_DATASET_ID"),
    access_token=access_token
)

print(status)

Typowe statusy mogą informować, czy refresh jest zakończony, nieudany albo nadal trwa. W automatyzacji warto czekać na zakończenie odświeżenia przed eksportem raportu.

Oczekiwanie na zakończenie odświeżenia

Poniższa funkcja cyklicznie sprawdza status odświeżenia i kończy działanie dopiero po sukcesie lub błędzie.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import time

def wait_for_dataset_refresh(
    workspace_id: str,
    dataset_id: str,
    access_token: str,
    timeout_seconds: int = 900,
    check_interval: int = 30
) -> bool:
    """Czeka na zakończenie odświeżenia datasetu."""
    start_time = time.time()

    while time.time() - start_time < timeout_seconds:
        latest = get_latest_refresh_status(workspace_id, dataset_id, access_token)

        if not latest:
            print("Brak informacji o odświeżeniu.")
            time.sleep(check_interval)
            continue

        status = latest.get("status")
        print(f"Aktualny status odświeżenia: {status}")

        if status == "Completed":
            print("Odświeżenie zakończone sukcesem.")
            return True

        if status == "Failed":
            print("Odświeżenie zakończone błędem.")
            print(latest)
            return False

        time.sleep(check_interval)

    print("Przekroczono czas oczekiwania na odświeżenie.")
    return False

To ważny element kompletnego pipeline’u. Bez niego możesz rozpocząć eksport raportu, zanim dane zostaną zaktualizowane.

Automatyczne przygotowanie danych dla Power BI

Czasem Power BI korzysta z pliku Excel, CSV lub innego źródła danych, które można wcześniej przygotować w Pythonie. Przykład: wczytanie danych, dodanie nowych rekordów i zapis do pliku źródłowego.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import pandas as pd
from datetime import datetime
from pathlib import Path

def update_power_bi_data_source(source_file: str, output_file: str):
    """Aktualizuje plik źródłowy używany przez Power BI."""
    source_path = Path(source_file)

    if source_path.exists():
        df = pd.read_excel(source_path)
    else:
        df = pd.DataFrame(columns=["Data", "Wartość", "Kategoria"])

    new_data = pd.DataFrame({
        "Data": [datetime.now()],
        "Wartość": [100],
        "Kategoria": ["Nowa"]
    })

    updated_df = pd.concat([df, new_data], ignore_index=True)
    updated_df.to_excel(output_file, index=False)

    print(f"Dane zaktualizowane: {output_file}. Liczba wierszy: {len(updated_df)}")


update_power_bi_data_source("dane_stare.xlsx", "dane_aktualne.xlsx")

W realnym projekcie dane mogą pochodzić z API, bazy PostgreSQL, plików CSV lub wewnętrznych systemów firmy.

Eksport raportu Power BI do PDF

Eksport raportu do PDF przez Power BI REST API zwykle działa asynchronicznie. Najpierw uruchamiasz eksport, potem sprawdzasz status, a na końcu pobierasz plik.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import requests
import time
from pathlib import Path

def start_power_bi_report_export(
    workspace_id: str,
    report_id: str,
    access_token: str,
    export_format: str = "PDF"
) -> str:
    """Rozpoczyna eksport raportu Power BI i zwraca export_id."""
    url = (
        f"https://api.powerbi.com/v1.0/myorg/groups/"
        f"{workspace_id}/reports/{report_id}/ExportTo"
    )

    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }

    payload = {
        "format": export_format
    }

    response = requests.post(url, headers=headers, json=payload, timeout=30)

    if response.status_code not in (200, 202):
        raise RuntimeError(f"Błąd eksportu: {response.status_code} {response.text}")

    data = response.json()
    export_id = data.get("id")

    if not export_id:
        raise RuntimeError(f"Brak export_id w odpowiedzi API: {data}")

    print(f"Eksport rozpoczęty. ID: {export_id}")
    return export_id


def wait_for_export(
    workspace_id: str,
    report_id: str,
    export_id: str,
    access_token: str,
    timeout_seconds: int = 900,
    check_interval: int = 10
) -> bool:
    """Czeka na zakończenie eksportu raportu."""
    url = (
        f"https://api.powerbi.com/v1.0/myorg/groups/"
        f"{workspace_id}/reports/{report_id}/exports/{export_id}"
    )

    headers = {
        "Authorization": f"Bearer {access_token}"
    }

    start_time = time.time()

    while time.time() - start_time < timeout_seconds:
        response = requests.get(url, headers=headers, timeout=30)
        response.raise_for_status()

        data = response.json()
        status = data.get("status")
        percent_complete = data.get("percentComplete")

        print(f"Status eksportu: {status}, postęp: {percent_complete}%")

        if status == "Succeeded":
            return True

        if status == "Failed":
            print(data)
            return False

        time.sleep(check_interval)

    print("Przekroczono czas oczekiwania na eksport.")
    return False


def download_exported_report(
    workspace_id: str,
    report_id: str,
    export_id: str,
    access_token: str,
    output_path: str
):
    """Pobiera wyeksportowany raport do pliku."""
    url = (
        f"https://api.powerbi.com/v1.0/myorg/groups/"
        f"{workspace_id}/reports/{report_id}/exports/{export_id}/file"
    )

    headers = {
        "Authorization": f"Bearer {access_token}"
    }

    response = requests.get(url, headers=headers, timeout=120)
    response.raise_for_status()

    Path(output_path).write_bytes(response.content)

    print(f"Raport zapisany do: {output_path}")

Użycie:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
workspace_id = os.getenv("POWER_BI_WORKSPACE_ID")
report_id = os.getenv("POWER_BI_REPORT_ID")
access_token = get_power_bi_access_token()

export_id = start_power_bi_report_export(
    workspace_id=workspace_id,
    report_id=report_id,
    access_token=access_token,
    export_format="PDF"
)

if wait_for_export(workspace_id, report_id, export_id, access_token):
    download_exported_report(
        workspace_id=workspace_id,
        report_id=report_id,
        export_id=export_id,
        access_token=access_token,
        output_path="raport_power_bi.pdf"
    )

Eksport danych do CSV

Power BI REST API może być używane nie tylko do eksportu raportu, ale też do pobierania danych z datasetu, np. przez zapytanie DAX. Wynik można zapisać do CSV.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import csv
import requests

def execute_dax_query_to_csv(
    workspace_id: str,
    dataset_id: str,
    access_token: str,
    dax_query: str,
    output_csv: str
):
    """Wykonuje zapytanie DAX na datasiecie i zapisuje wynik do CSV."""
    url = (
        f"https://api.powerbi.com/v1.0/myorg/groups/"
        f"{workspace_id}/datasets/{dataset_id}/executeQueries"
    )

    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }

    payload = {
        "queries": [
            {
                "query": dax_query
            }
        ],
        "serializerSettings": {
            "includeNulls": True
        }
    }

    response = requests.post(url, headers=headers, json=payload, timeout=60)
    response.raise_for_status()

    results = response.json()["results"][0]["tables"][0]["rows"]

    if not results:
        print("Zapytanie nie zwróciło danych.")
        return

    fieldnames = list(results[0].keys())

    with open(output_csv, "w", encoding="utf-8", newline="") as file:
        writer = csv.DictWriter(file, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(results)

    print(f"Dane zapisane do: {output_csv}")

Przykład zapytania:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
dax_query = """
EVALUATE
TOPN(
    100,
    'Sales',
    'Sales'[Date],
    DESC
)
"""

execute_dax_query_to_csv(
    workspace_id=os.getenv("POWER_BI_WORKSPACE_ID"),
    dataset_id=os.getenv("POWER_BI_DATASET_ID"),
    access_token=access_token,
    dax_query=dax_query,
    output_csv="dane_power_bi.csv"
)

To przydatne, gdy chcesz wyciągnąć dane z modelu Power BI do dalszego przetwarzania lub archiwizacji.

Harmonogram automatycznego odświeżania

Do prostego harmonogramu lokalnego możesz użyć biblioteki schedule. Poniższy przykład uruchamia proces codziennie o 8:00.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import os
import time
import schedule
from datetime import datetime

def refresh_power_bi_job():
    """Zadanie harmonogramowe odświeżające Power BI."""
    print(f"[{datetime.now()}] Start odświeżania Power BI")

    access_token = get_power_bi_access_token()

    workspace_id = os.getenv("POWER_BI_WORKSPACE_ID")
    dataset_id = os.getenv("POWER_BI_DATASET_ID")

    refresh_started = refresh_power_bi_dataset(
        workspace_id=workspace_id,
        dataset_id=dataset_id,
        access_token=access_token
    )

    if refresh_started:
        wait_for_dataset_refresh(
            workspace_id=workspace_id,
            dataset_id=dataset_id,
            access_token=access_token
        )

    print(f"[{datetime.now()}] Koniec zadania Power BI")


schedule.every().day.at("08:00").do(refresh_power_bi_job)
schedule.every().monday.at("09:00").do(refresh_power_bi_job)

print("Harmonogram Power BI uruchomiony.")

while True:
    schedule.run_pending()
    time.sleep(60)

W produkcji można użyć też crona, APScheduler, GitHub Actions, Azure Functions lub innego systemu harmonogramowania.

Wysyłka raportu e-mailem

Po wyeksportowaniu raportu do PDF możesz wysłać go e-mailem jako załącznik. Dane SMTP również warto trzymać w zmiennych środowiskowych.

Przykładowe zmienne:

ENV
Kopiuj
1
2
3
4
SMTP_HOST=smtp.example.com
SMTP_PORT=587
SMTP_USER=raporty@firma.pl
SMTP_PASSWORD=your-password

Kod wysyłki:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import os
import smtplib
from pathlib import Path
from email import encoders
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

def send_power_bi_report_email(
    report_path: str,
    recipient: str,
    subject: str = "Raport Power BI"
):
    """Wysyła raport Power BI e-mailem."""
    path = Path(report_path)

    if not path.exists():
        raise FileNotFoundError(f"Nie znaleziono raportu: {report_path}")

    msg = MIMEMultipart()
    msg["From"] = os.getenv("SMTP_USER")
    msg["To"] = recipient
    msg["Subject"] = subject

    body = "Cześć,\n\nw załączniku znajduje się aktualny raport Power BI.\n"
    msg.attach(MIMEText(body, "plain", "utf-8"))

    with open(path, "rb") as file:
        part = MIMEBase("application", "octet-stream")
        part.set_payload(file.read())

    encoders.encode_base64(part)
    part.add_header(
        "Content-Disposition",
        f'attachment; filename="{path.name}"'
    )

    msg.attach(part)

    smtp_host = os.getenv("SMTP_HOST")
    smtp_port = int(os.getenv("SMTP_PORT", "587"))
    smtp_user = os.getenv("SMTP_USER")
    smtp_password = os.getenv("SMTP_PASSWORD")

    with smtplib.SMTP(smtp_host, smtp_port) as server:
        server.starttls()
        server.login(smtp_user, smtp_password)
        server.send_message(msg)

    print(f"Raport wysłany do: {recipient}")

Użycie:

Python
Kopiuj
1
2
3
4
5
send_power_bi_report_email(
    report_path="raport_power_bi.pdf",
    recipient="uzytkownik@firma.pl",
    subject="Raport Power BI - dzienny"
)

Kompletny pipeline Power BI w Pythonie

Poniżej przykład funkcji, która łączy cały proces: przygotowanie danych, odświeżenie datasetu, oczekiwanie na zakończenie, eksport raportu i wysyłkę e-mail.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import os
from datetime import datetime

def complete_power_bi_automation():
    """Kompletna automatyzacja Power BI: dane -> refresh -> eksport -> e-mail."""
    print(f"[{datetime.now()}] Rozpoczynam automatyzację Power BI")

    workspace_id = os.getenv("POWER_BI_WORKSPACE_ID")
    dataset_id = os.getenv("POWER_BI_DATASET_ID")
    report_id = os.getenv("POWER_BI_REPORT_ID")

    access_token = get_power_bi_access_token()

    # 1. Przygotowanie danych źródłowych
    update_power_bi_data_source("dane_stare.xlsx", "dane_aktualne.xlsx")

    # 2. Odświeżenie datasetu
    refresh_started = refresh_power_bi_dataset(
        workspace_id=workspace_id,
        dataset_id=dataset_id,
        access_token=access_token
    )

    if not refresh_started:
        raise RuntimeError("Nie udało się uruchomić odświeżenia datasetu.")

    # 3. Oczekiwanie na zakończenie refreshu
    refresh_ok = wait_for_dataset_refresh(
        workspace_id=workspace_id,
        dataset_id=dataset_id,
        access_token=access_token
    )

    if not refresh_ok:
        raise RuntimeError("Odświeżenie datasetu zakończyło się błędem.")

    # 4. Eksport raportu do PDF
    output_pdf = "raport_power_bi.pdf"

    export_id = start_power_bi_report_export(
        workspace_id=workspace_id,
        report_id=report_id,
        access_token=access_token,
        export_format="PDF"
    )

    export_ok = wait_for_export(
        workspace_id=workspace_id,
        report_id=report_id,
        export_id=export_id,
        access_token=access_token
    )

    if not export_ok:
        raise RuntimeError("Eksport raportu zakończył się błędem.")

    download_exported_report(
        workspace_id=workspace_id,
        report_id=report_id,
        export_id=export_id,
        access_token=access_token,
        output_path=output_pdf
    )

    # 5. Wysyłka raportu
    send_power_bi_report_email(
        report_path=output_pdf,
        recipient="uzytkownik@firma.pl",
        subject="Automatyczny raport Power BI"
    )

    print(f"[{datetime.now()}] Automatyzacja Power BI zakończona")

Harmonogram codzienny:

Python
Kopiuj
1
2
3
4
5
6
7
8
import schedule
import time

schedule.every().day.at("08:00").do(complete_power_bi_automation)

while True:
    schedule.run_pending()
    time.sleep(60)

Logowanie błędów w automatyzacji Power BI

W procesach raportowych warto zapisywać błędy do pliku. Dzięki temu łatwiej sprawdzić, dlaczego raport nie został wysłany.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import logging

logging.basicConfig(
    filename="power_bi_automation.log",
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)

def safe_power_bi_job():
    """Uruchamia pipeline Power BI z logowaniem błędów."""
    try:
        logging.info("Start automatyzacji Power BI")
        complete_power_bi_automation()
        logging.info("Automatyzacja Power BI zakończona sukcesem")

    except Exception as error:
        logging.exception(f"Błąd automatyzacji Power BI: {error}")

W harmonogramie możesz uruchamiać safe_power_bi_job() zamiast bezpośrednio complete_power_bi_automation().

Dobre praktyki automatyzacji Power BI z Pythona

Automatyzacja raportowania powinna być stabilna i bezpieczna. Warto trzymać się kilku zasad:

• przechowuj tokeny, hasła i identyfikatory w zmiennych środowiskowych,
• sprawdzaj status odświeżenia datasetu przed eksportem raportu,
• loguj błędy i czas wykonania zadań,
• nie wysyłaj raportu, jeśli odświeżenie danych się nie powiodło,
• dodaj timeouty do zapytań HTTP,
• używaj retry dla błędów tymczasowych,
• zapisuj wygenerowane raporty w katalogu archiwum,
• kontroluj dostęp do mailboxa i tokenów API,
• testuj pipeline na małym raporcie przed wdrożeniem produkcyjnym,
• dokumentuj wymagane uprawnienia i zmienne środowiskowe.

Te zasady zmniejszają ryzyko wysłania nieaktualnych lub błędnych danych do odbiorców.

Podsumowanie

Automatyzacja raportów Power BI z Pythona pozwala zbudować kompletny workflow raportowy: przygotowanie danych, odświeżenie datasetu, kontrolę statusu, eksport raportu, zapis danych do CSV, harmonogram i wysyłkę e-mail.

Najważniejsze elementy to Power BI REST API, token dostępu, biblioteka requests, obsługa statusów, logowanie błędów i bezpieczne przechowywanie sekretów. Dzięki temu raporty mogą być generowane regularnie i bez ręcznej obsługi.

Jeśli chcesz zacząć praktycznie, zautomatyzuj najpierw jeden mały krok: odświeżenie datasetu. Potem dodaj sprawdzanie statusu, eksport do PDF i wysyłkę e-mail. W ten sposób zbudujesz stabilny pipeline raportowania krok po kroku.

➡️ Następny artykuł

Po automatyzacji raportowania poznaj fundamenty pracy z bazami danych:

Praca z bazą danych w automatyzacji: SQLite/PostgreSQL — wzorce połączeń, transakcje, migracje i tworzenie niezawodnych pipeline'ów ETL w Pythonie.