claudient 0.1.0

package/skills/backend/python/de/fastapi.md

@@ -0,0 +1,244 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../fastapi.md).
+
+# FastAPI Skill
+
+## Wann aktivieren
+- Eine Python REST- oder asynchrone API mit FastAPI bauen
+- Pydantic-Anfrage-/Antwortmodelle definieren
+- Dependency Injection mit `Depends` einrichten
+- Asynchrone Route-Handler mit SQLAlchemy oder asynchronen DB-Treibern schreiben
+- Middleware hinzufügen (CORS, Auth, Logging, Rate Limiting)
+- Hintergrundaufgaben oder Celery-Worker konfigurieren
+- OpenAPI-Docs anpassen (Tags, Beschreibungen, Antwort-Schemas)
+- Integrationstests mit `TestClient` oder `AsyncClient` schreiben
+- Ein Multi-Modul-FastAPI-Projekt strukturieren
+
+## Wann NICHT verwenden
+- Django/DRF-Projekte — Django Skill verwenden
+- Nur-synchrone Codebasen, bei denen Async-Overhead nicht gerechtfertigt ist
+- Einfache Skripte, die kein HTTP benötigen — einfaches Python verwenden
+- gRPC- oder GraphQL-APIs — anderer Transport und Schema-Layer
+
+## Anweisungen
+
+### Projektstruktur
+```
+app/
+├── main.py              # FastAPI App-Factory
+├── core/
+│   ├── config.py        # Einstellungen über pydantic-settings
+│   └── security.py      # JWT, Hashing-Utilities
+├── api/
+│   ├── deps.py          # Gemeinsame Depends()-Funktionen
+│   └── v1/
+│       ├── router.py    # APIRouter-Aggregator
+│       └── endpoints/
+│           ├── users.py
+│           └── items.py
+├── models/              # SQLAlchemy ORM-Modelle
+├── schemas/             # Pydantic Anfrage-/Antwort-Schemas
+├── crud/                # DB-Operationsfunktionen (kein ORM, kein HTTP)
+└── db/
+    ├── session.py       # AsyncSession-Factory
+    └── base.py          # Deklarative Basis-Import
+```
+
+### App-Factory
+```python
+# main.py
+from fastapi import FastAPI
+from app.api.v1.router import api_router
+from app.core.config import settings
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title=settings.PROJECT_NAME,
+        openapi_url=f"{settings.API_V1_STR}/openapi.json",
+        docs_url="/docs" if settings.ENVIRONMENT != "production" else None,
+    )
+    app.include_router(api_router, prefix=settings.API_V1_STR)
+    return app
+
+app = create_app()
+```
+
+### Einstellungen mit pydantic-settings
+```python
+# core/config.py
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "MyAPI"
+    API_V1_STR: str = "/api/v1"
+    DATABASE_URL: str
+    SECRET_KEY: str
+    ENVIRONMENT: str = "development"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings()
+```
+
+### Asynchrone SQLAlchemy-Session-Abhängigkeit
+```python
+# db/session.py
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
+
+engine = create_async_engine(settings.DATABASE_URL, echo=False)
+AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)
+
+# api/deps.py
+async def get_db() -> AsyncIterator[AsyncSession]:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+```
+
+### Route-Handler
+```python
+# api/v1/endpoints/users.py
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.api.deps import get_db, get_current_user
+from app.crud import user as crud_user
+from app.schemas.user import UserCreate, UserResponse
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+@router.post("/", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
+async def create_user(
+    payload: UserCreate,
+    db: AsyncSession = Depends(get_db),
+) -> UserResponse:
+    if await crud_user.get_by_email(db, email=payload.email):
+        raise HTTPException(status_code=400, detail="Email already registered")
+    return await crud_user.create(db, obj_in=payload)
+```
+
+### Dependency Injection für Auth
+```python
+# api/deps.py
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/token")
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db),
+) -> User:
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+    user = await crud_user.get(db, id=user_id)
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+```
+
+### Hintergrundaufgaben
+```python
+# FastAPI's BackgroundTasks für leichtgewichtiges Fire-and-Forget verwenden (kein Ergebnis benötigt)
+@router.post("/send-email")
+async def send_email_endpoint(
+    payload: EmailPayload,
+    background_tasks: BackgroundTasks,
+):
+    background_tasks.add_task(send_email, payload.to, payload.subject, payload.body)
+    return {"status": "queued"}
+
+# Celery verwenden für: Wiederholungen, Ergebnisverfolgung, Planung, dienstübergreifende Aufgaben
+```
+
+### CORS-Middleware
+```python
+from fastapi.middleware.cors import CORSMiddleware
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,  # Niemals ["*"] in der Produktion
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+```
+
+### Benutzerdefinierte Exception-Handler
+```python
+from fastapi.responses import JSONResponse
+
+@app.exception_handler(ValueError)
+async def value_error_handler(request: Request, exc: ValueError) -> JSONResponse:
+    return JSONResponse(status_code=422, content={"detail": str(exc)})
+```
+
+### Tests
+```python
+# tests/conftest.py
+import pytest
+from httpx import AsyncClient, ASGITransport
+from app.main import app
+
+@pytest.fixture
+async def client() -> AsyncIterator[AsyncClient]:
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as ac:
+        yield ac
+
+# tests/test_users.py
+@pytest.mark.asyncio
+async def test_create_user(client: AsyncClient, db_session):
+    resp = await client.post("/api/v1/users/", json={"email": "a@b.com", "password": "secret"})
+    assert resp.status_code == 201
+    assert resp.json()["email"] == "a@b.com"
+```
+
+### Häufige Pydantic-Muster
+```python
+from pydantic import BaseModel, EmailStr, field_validator, model_validator
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str
+
+    @field_validator("password")
+    @classmethod
+    def password_strength(cls, v: str) -> str:
+        if len(v) < 8:
+            raise ValueError("Password must be at least 8 characters")
+        return v
+
+class UserResponse(BaseModel):
+    id: int
+    email: EmailStr
+
+    model_config = {"from_attributes": True}  # ersetzt orm_mode = True
+```
+
+## Beispiel
+
+**Benutzer:** Einen FastAPI-Endpunkt zum Erstellen eines Blog-Posts bauen, mit JWT authentifiziert und in PostgreSQL mit asynchronem SQLAlchemy gespeichert.
+
+**Erwartete Struktur:**
+- `schemas/post.py` — `PostCreate(BaseModel)`, `PostResponse(BaseModel)` mit `from_attributes=True`
+- `models/post.py` — `Post` ORM-Modell mit `id`, `title`, `body`, `author_id` (FK zu User), `created_at`
+- `crud/post.py` — `create(db, *, obj_in, author_id)` asynchrone Funktion
+- `api/v1/endpoints/posts.py` — `POST /posts/` mit `Depends(get_current_user)` und `Depends(get_db)`
+- `api/v1/router.py` — Posts-Router einschließen
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)

package/skills/backend/python/django.md

@@ -0,0 +1,283 @@
+# Django Skill
+
+## When to activate
+- Building a Django project with ORM models, migrations, and views
+- Setting up Django REST Framework (DRF) serializers, viewsets, and routers
+- Writing custom model managers or QuerySet methods
+- Using Django signals for decoupled side effects
+- Setting up Celery for async tasks in a Django project
+- Customizing the Django admin
+- Writing tests with `django.test.TestCase` or `pytest-django`
+
+## When NOT to use
+- Async-first APIs — use FastAPI skill instead
+- Microservices that don't need Django's ORM or admin
+- Simple scripts or CLIs — plain Python or Typer
+- If the project already uses FastAPI or Flask
+
+## Instructions
+
+### Project layout
+```
+project_name/
+├── manage.py
+├── config/
+│   ├── settings/
+│   │   ├── base.py
+│   │   ├── development.py
+│   │   └── production.py
+│   ├── urls.py
+│   └── wsgi.py
+├── apps/
+│   └── users/
+│       ├── models.py
+│       ├── serializers.py
+│       ├── views.py
+│       ├── urls.py
+│       ├── admin.py
+│       ├── managers.py
+│       └── tests/
+└── requirements/
+    ├── base.txt
+    ├── development.txt
+    └── production.txt
+```
+
+### Settings split
+```python
+# config/settings/base.py
+from pathlib import Path
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "rest_framework",
+    "apps.users",
+]
+
+AUTH_USER_MODEL = "users.User"  # Always set a custom user model from day one
+
+# config/settings/production.py
+from .base import *
+DEBUG = False
+ALLOWED_HOSTS = env.list("ALLOWED_HOSTS")
+DATABASES = {"default": env.db("DATABASE_URL")}
+```
+
+### Custom User model
+```python
+# apps/users/models.py — set up before first migration, never change afterwards
+from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
+from django.db import models
+from .managers import UserManager
+
+class User(AbstractBaseUser, PermissionsMixin):
+    email = models.EmailField(unique=True)
+    is_staff = models.BooleanField(default=False)
+    is_active = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS = []
+    objects = UserManager()
+```
+
+### Custom Manager
+```python
+# apps/users/managers.py
+from django.contrib.auth.base_user import BaseUserManager
+
+class UserManager(BaseUserManager):
+    def create_user(self, email: str, password: str, **extra_fields):
+        if not email:
+            raise ValueError("Email is required")
+        email = self.normalize_email(email)
+        user = self.model(email=email, **extra_fields)
+        user.set_password(password)
+        user.save()
+        return user
+
+    def create_superuser(self, email: str, password: str, **extra_fields):
+        extra_fields.setdefault("is_staff", True)
+        extra_fields.setdefault("is_superuser", True)
+        return self.create_user(email, password, **extra_fields)
+
+    def active(self):
+        return self.get_queryset().filter(is_active=True)
+```
+
+### DRF Serializers
+```python
+# apps/users/serializers.py
+from rest_framework import serializers
+from .models import User
+
+class UserCreateSerializer(serializers.ModelSerializer):
+    password = serializers.CharField(write_only=True, min_length=8)
+
+    class Meta:
+        model = User
+        fields = ["id", "email", "password"]
+
+    def create(self, validated_data: dict) -> User:
+        return User.objects.create_user(**validated_data)
+
+class UserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = ["id", "email", "created_at"]
+        read_only_fields = ["id", "created_at"]
+```
+
+### DRF ViewSets
+```python
+# apps/users/views.py
+from rest_framework import viewsets, permissions, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from .models import User
+from .serializers import UserSerializer, UserCreateSerializer
+
+class UserViewSet(viewsets.ModelViewSet):
+    queryset = User.objects.active()
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_serializer_class(self):
+        if self.action == "create":
+            return UserCreateSerializer
+        return UserSerializer
+
+    def get_permissions(self):
+        if self.action == "create":
+            return [permissions.AllowAny()]
+        return super().get_permissions()
+
+    @action(detail=False, methods=["get"])
+    def me(self, request):
+        return Response(UserSerializer(request.user).data)
+```
+
+### Router setup
+```python
+# apps/users/urls.py
+from rest_framework.routers import DefaultRouter
+from .views import UserViewSet
+
+router = DefaultRouter()
+router.register("users", UserViewSet, basename="user")
+urlpatterns = router.urls
+```
+
+### Signals
+```python
+# apps/users/signals.py — use signals for truly decoupled side effects only
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from .models import User
+
+@receiver(post_save, sender=User)
+def send_welcome_email(sender, instance: User, created: bool, **kwargs):
+    if created:
+        send_email_task.delay(instance.email, "welcome")
+
+# apps/users/apps.py
+class UsersConfig(AppConfig):
+    name = "apps.users"
+    def ready(self):
+        import apps.users.signals  # noqa: F401
+```
+
+### Celery
+```python
+# config/celery.py
+from celery import Celery
+import os
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings.production")
+app = Celery("project_name")
+app.config_from_object("django.conf:settings", namespace="CELERY")
+app.autodiscover_tasks()
+
+# apps/users/tasks.py
+from config.celery import app
+
+@app.task(bind=True, max_retries=3)
+def send_email_task(self, to_email: str, template: str):
+    try:
+        # send email
+        pass
+    except Exception as exc:
+        raise self.retry(exc=exc, countdown=60)
+```
+
+### Admin customization
+```python
+# apps/users/admin.py
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from .models import User
+
+@admin.register(User)
+class UserAdmin(BaseUserAdmin):
+    list_display = ["email", "is_active", "is_staff", "created_at"]
+    list_filter = ["is_active", "is_staff"]
+    search_fields = ["email"]
+    ordering = ["-created_at"]
+    fieldsets = (
+        (None, {"fields": ("email", "password")}),
+        ("Permissions", {"fields": ("is_active", "is_staff", "is_superuser", "groups")}),
+    )
+    add_fieldsets = (
+        (None, {"fields": ("email", "password1", "password2")}),
+    )
+```
+
+### QuerySet optimization
+```python
+# Always select_related for FK fields, prefetch_related for M2M/reverse FK
+posts = Post.objects.select_related("author").prefetch_related("tags").filter(published=True)
+
+# Use only() or defer() for large models when you only need specific fields
+emails = User.objects.filter(is_active=True).only("email")
+
+# Use values() for read-only aggregations — skips ORM object construction
+counts = Order.objects.values("status").annotate(count=Count("id"))
+```
+
+### Testing
+```python
+# pytest-django style
+import pytest
+from rest_framework.test import APIClient
+
+@pytest.fixture
+def api_client():
+    return APIClient()
+
+@pytest.fixture
+def authenticated_client(api_client, user):
+    api_client.force_authenticate(user=user)
+    return api_client
+
+@pytest.mark.django_db
+def test_create_user(api_client):
+    resp = api_client.post("/api/users/", {"email": "a@b.com", "password": "strongpass"})
+    assert resp.status_code == 201
+    assert resp.data["email"] == "a@b.com"
+```
+
+## Example
+
+**User:** Add a `Post` model to a Django project with DRF, including list/create/retrieve endpoints, paginated results, and filter by `published=True`.
+
+**Expected output:**
+- `models.py` — `Post` with `title`, `body`, `author` (FK to User), `published`, `created_at`
+- `serializers.py` — `PostSerializer` with read-only `author` (nested), writable `title`/`body`/`published`
+- `views.py` — `PostViewSet` with `queryset` filtered to `published=True` for unauthenticated users, `IsAuthenticatedOrReadOnly` permission, `PageNumberPagination`
+- `urls.py` — router registered at `/api/posts/`
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)