Python
Playwright
OpenAI SDK
python-dotenv
PyYAML

python3 --version

mkdir -p social-publisher
cd social-publisher

python3 -m venv .venv

source .venv/bin/activate

python -m pip install --upgrade pip

.\.venv\Scripts\Activate.ps1

pip install openai playwright python-dotenv pyyaml pytest

pip freeze > requirements.txt

openai
playwright
python-dotenv
pyyaml
pytest

python -m playwright install chromium

sudo .venv/bin/python -m playwright install --with-deps chromium

python -m playwright install --list

src/openai_client.py

from openai import OpenAI


class OpenAiClient:
    def __init__(self) -> None:
        self.client = OpenAI()

    def create_text(self, prompt: str) -> str:
        response = self.client.responses.create(
            model="gpt-4.1-mini",
            input=prompt,
        )

        output_text = response.output_text

        if isinstance(output_text, str) is False:
            raise RuntimeError("OpenAI response did not contain text output.")

        if output_text.strip() == "":
            raise RuntimeError("OpenAI response was empty.")

        return output_text

.env

OPENAI_API_KEY=sk-...
APP_ENV=dev
APP_TIMEZONE=Europe/Berlin
DRY_RUN=true

.env.example

OPENAI_API_KEY=
APP_ENV=dev
APP_TIMEZONE=Europe/Berlin
DRY_RUN=true

.venv/
.env
__pycache__/
.pytest_cache/
storage/sessions/
storage/screenshots/
storage/logs/

src/config.py

import os
from dataclasses import dataclass
from pathlib import Path

import yaml
from dotenv import load_dotenv


@dataclass(frozen=True)
class AppConfig:
    app_env: str
    timezone: str
    dry_run: bool
    root_dir: Path
    config_file: Path


class ConfigLoader:
    def __init__(self, root_dir: Path) -> None:
        self.root_dir = root_dir

    def load(self) -> AppConfig:
        load_dotenv(self.root_dir / ".env")

        app_env = os.getenv("APP_ENV")
        timezone = os.getenv("APP_TIMEZONE")
        dry_run_value = os.getenv("DRY_RUN")

        if app_env is None:
            raise RuntimeError("Missing APP_ENV.")

        if timezone is None:
            raise RuntimeError("Missing APP_TIMEZONE.")

        if dry_run_value is None:
            raise RuntimeError("Missing DRY_RUN.")

        if dry_run_value == "true":
            dry_run = True
        elif dry_run_value == "false":
            dry_run = False
        else:
            raise RuntimeError("DRY_RUN must be true or false.")

        config_file = self.root_dir / "config.yaml"

        if config_file.exists() is False:
            raise RuntimeError("Missing config.yaml.")

        with config_file.open("r", encoding="utf-8") as file:
            yaml.safe_load(file)

        return AppConfig(
            app_env=app_env,
            timezone=timezone,
            dry_run=dry_run,
            root_dir=self.root_dir,
            config_file=config_file,
        )

mkdir -p data
mkdir -p prompts
mkdir -p src/platforms
mkdir -p storage/sessions
mkdir -p storage/screenshots
mkdir -p storage/images
mkdir -p storage/logs
mkdir -p tests
touch src/__init__.py
touch src/platforms/__init__.py

social-publisher/
├── .env
├── .env.example
├── .gitignore
├── config.yaml
├── requirements.txt
├── data/
│   ├── books.json
│   ├── topics.json
│   ├── drafts.json
│   ├── approved_posts.json
│   └── published_posts.json
├── prompts/
│   └── smoke_test.txt
├── src/
│   ├── __init__.py
│   ├── main.py
│   ├── config.py
│   ├── openai_client.py
│   └── platforms/
│       └── __init__.py
├── storage/
│   ├── sessions/
│   ├── screenshots/
│   ├── images/
│   └── logs/
└── tests/

printf "[]\n" > data/books.json
printf "[]\n" > data/topics.json
printf "[]\n" > data/drafts.json
printf "[]\n" > data/approved_posts.json
printf "[]\n" > data/published_posts.json

platforms:
  linkedin:
    enabled: true
    session_path: "storage/sessions/linkedin.json"
    screenshots_path: "storage/screenshots/linkedin"

limits:
  max_posts_per_day: 1
  max_comments_per_day: 3
  max_likes_per_day: 10

prompts/smoke_test.txt

Schreibe einen sachlichen Ein-Satz-Testbeitrag für einen kleinen deutschen E-Book-Verlag. Keine Emojis. Keine Hashtags.

Konfiguration wird geladen.
OpenAI antwortet.
Playwright kann Chromium starten und einen Screenshot speichern.

src/main.py

from pathlib import Path

from playwright.sync_api import sync_playwright

from src.config import ConfigLoader
from src.openai_client import OpenAiClient


def run_openai_smoke_test(root_dir: Path) -> None:
    prompt_file = root_dir / "prompts" / "smoke_test.txt"

    if prompt_file.exists() is False:
        raise RuntimeError("Missing prompts/smoke_test.txt.")

    prompt = prompt_file.read_text(encoding="utf-8")

    client = OpenAiClient()
    text = client.create_text(prompt)

    print("OPENAI_OK")
    print(text)


def run_playwright_smoke_test(root_dir: Path) -> None:
    screenshot_file = root_dir / "storage" / "screenshots" / "smoke_test.png"

    with sync_playwright() as playwright:
        browser = playwright.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto("https://example.com", wait_until="domcontentloaded")
        page.screenshot(path=str(screenshot_file), full_page=True)
        browser.close()

    if screenshot_file.exists() is False:
        raise RuntimeError("Playwright screenshot was not created.")

    print("PLAYWRIGHT_OK")
    print(str(screenshot_file))


def main() -> None:
    root_dir = Path(__file__).resolve().parent.parent

    config_loader = ConfigLoader(root_dir)
    config = config_loader.load()

    print("CONFIG_OK")
    print(config)

    run_openai_smoke_test(root_dir)
    run_playwright_smoke_test(root_dir)


if __name__ == "__main__":
    main()

python -m src.main

CONFIG_OK
AppConfig(...)
OPENAI_OK
...
PLAYWRIGHT_OK
.../storage/screenshots/smoke_test.png

Python-Umgebung steht.
Abhängigkeiten sind installiert.
Playwright startet Chromium.
OpenAI-Client erzeugt Text.
.env wird geladen.
Projektstruktur ist vorbereitet.
Smoke-Test erzeugt einen Screenshot.