clash-sub-manager 0.1.0__tar.gz

clash_sub_manager-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.3
+Name: clash-sub-manager
+Version: 0.1.0
+Summary: Clash subscription management web service
+Author: shoucandanghehe
+Author-email: shoucandanghehe <wallfjjd@gmail.com>
+Requires-Dist: fastapi>=0.135.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: uvicorn>=0.38.0
+Requires-Dist: cyclopts>=4.9.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+

clash_sub_manager-0.1.0/pyproject.toml

@@ -0,0 +1,154 @@
+[project]
+name = "clash-sub-manager"
+version = "0.1.0"
+description = "Clash subscription management web service"
+readme = "README.md"
+authors = [{ name = "shoucandanghehe", email = "wallfjjd@gmail.com" }]
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.135.1",
+    "pydantic>=2.12.5",
+    "uvicorn>=0.38.0",
+    "cyclopts>=4.9.0",
+    "httpx>=0.27.0",
+    "pyyaml>=6.0.1",
+    "sqlalchemy[asyncio]>=2.0",
+    "aiosqlite>=0.20.0",
+]
+
+[project.scripts]
+clash-sub-manager = "clash_sub_manager.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.10.6,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.fastapi]
+entrypoint = "clash_sub_manager.api.server:app"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "F",     # pyflakes
+    "E",     # pycodestyle errors
+    "W",     # pycodestyle warnings
+    "C90",   # mccabe
+    "I",     # isort
+    "N",     # PEP8-naming
+    "UP",    # pyupgrade
+    "YTT",   # flake8-2020
+    "ANN",   # flake8-annotations
+    "ASYNC", # flake8-async
+    "S",     # flake8-bandit
+    "BLE",   # flake8-blind-except
+    "FBT",   # flake8-boolean-trap
+    "B",     # flake8-bugbear
+    "A",     # flake8-builtins
+    "COM",   # flake8-commas
+    "C4",    # flake8-comprehensions
+    "DTZ",   # flake8-datetimez
+    "T10",   # flake8-debugger
+    "EM",    # flake8-errmsg
+    "FA",    # flake8-future-annotations
+    "ISC",   # flake8-implicit-str-concat
+    "ICN",   # flake8-import-conventions
+    "PIE",   # flake8-pie
+    "T20",   # flake8-print
+    "PYI",   # flake8-pyi
+    "Q",     # flake8-quotes
+    "RSE",   # flake8-raise
+    "RET",   # flake8-return
+    "SLF",   # flake8-self
+    "SLOT",  # flake8-slots
+    "SIM",   # flake8-simplify
+    "TID",   # flake8-tidy-imports
+    "TC",    # flake8-type-checking
+    "ARG",   # flake8-unused-arguments
+    "PTH",   # flake8-use-pathlib
+    "ERA",   # eradicate
+    "PD",    # pandas-vet
+    "PGH",   # pygrep-hooks
+    "PL",    # pylint
+    "TRY",   # tryceratops
+    "FLY",   # flynt
+    "FAST",  # FastAPI
+    "PERF",  # Perflint
+    "FURB",  # refurb
+    "RUF",   # Ruff-specific rules
+]
+ignore = [
+    "E501",   # 过长的行由 ruff format 处理, 剩余的都是字符串
+    "TRY003",
+    "COM812", # 强制尾随逗号
+    "TID252", # 相对导入
+    "ISC001", # format warning
+]
+flake8-quotes = { inline-quotes = "single", multiline-quotes = "double" }
+
+[tool.ruff.lint.flake8-annotations]
+mypy-init-return = true
+
+[tool.ruff.lint.flake8-builtins]
+builtins-ignorelist = ["id"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101", "S603", "PLR2004"]
+
+[tool.ruff.format]
+quote-style = "single"
+
+[tool.basedpyright]
+pythonVersion = "3.10"
+pythonPlatform = "All"
+typeCheckingMode = "standard"
+reportExplicitAny = 'hint'
+reportUnnecessaryTypeIgnoreComment = 'error'
+reportImplicitOverride = 'error'
+reportUnnecessaryComparison = 'error'
+reportImplicitAbstractClass = 'error'
+enableTypeIgnoreComments = false
+
+[tool.bumpversion]
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = true
+tag_name = "v{new_version}"
+tag_message = "🔖 bump version {new_version}"
+allow_dirty = true
+commit = true
+message = "🔖 bump version {new_version}"
+moveable_tags = []
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = "version = \"{current_version}\""
+replace = "version = \"{new_version}\""
+
+[[tool.bumpversion.files]]
+filename = "src/clash_sub_manager/__init__.py"
+search = "__version__ = '{current_version}'"
+replace = "__version__ = '{new_version}'"
+
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.38.2",
+    "bump-my-version>=1.2.4",
+    "mypy>=1.19.1",
+    "ruff>=0.15.6",
+    "pytest>=8.4.2",
+    "pytest-asyncio>=1.2.0",
+]

clash_sub_manager-0.1.0/src/clash_sub_manager/__init__.py

@@ -0,0 +1,5 @@
+"""Clash subscription management web service."""
+
+__all__ = ['__version__']
+
+__version__ = '0.1.0'

clash_sub_manager-0.1.0/src/clash_sub_manager/__main__.py

@@ -0,0 +1,4 @@
+from clash_sub_manager.cli import main
+
+if __name__ == '__main__':
+    main()

clash_sub_manager-0.1.0/src/clash_sub_manager/api/__init__.py

@@ -0,0 +1,3 @@
+from .server import app, create_app
+
+__all__ = ['app', 'create_app']

clash_sub_manager-0.1.0/src/clash_sub_manager/api/dependencies.py

@@ -0,0 +1,19 @@
+"""FastAPI dependency helpers."""
+
+from collections.abc import AsyncIterator
+
+from fastapi import Request
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+
+def get_session_factory(request: Request) -> async_sessionmaker[AsyncSession]:
+    return request.app.state.session_factory
+
+
+async def get_db_session(request: Request) -> AsyncIterator[AsyncSession]:
+    session_factory = get_session_factory(request)
+    async with session_factory() as session:
+        yield session
+
+
+__all__ = ['get_db_session', 'get_session_factory']

clash_sub_manager-0.1.0/src/clash_sub_manager/api/routes/__init__.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from .composite_templates import router as composite_templates_router
+from .config import router as config_router
+from .convert import router as convert_router
+from .merge import router as merge_router
+from .merge_profiles import router as merge_profiles_router
+from .rules import router as rules_router
+from .template_patches import router as template_patches_router
+
+api_router = APIRouter()
+api_router.include_router(convert_router)
+api_router.include_router(merge_router)
+api_router.include_router(merge_profiles_router)
+api_router.include_router(composite_templates_router)
+api_router.include_router(template_patches_router)
+api_router.include_router(config_router)
+api_router.include_router(rules_router)
+
+__all__ = ['api_router']

clash_sub_manager-0.1.0/src/clash_sub_manager/api/routes/_db.py

@@ -0,0 +1,34 @@
+"""Shared database helpers for API routes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from fastapi import HTTPException, status
+from sqlalchemy.exc import IntegrityError
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+def _is_unique_name_violation(exc: IntegrityError, *, table_name: str) -> bool:
+    message = str(exc.orig).lower()
+    return 'unique' in message and (
+        f'{table_name}.name' in message or f'uq_{table_name}_name' in message
+    )
+
+
+async def commit_or_name_conflict(db: AsyncSession, *, resource_name: str, table_name: str) -> None:
+    try:
+        await db.commit()
+    except IntegrityError as exc:
+        await db.rollback()
+        if _is_unique_name_violation(exc, table_name=table_name):
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=f'{resource_name} name already exists',
+            ) from exc
+        raise
+
+
+__all__ = ['commit_or_name_conflict']

clash_sub_manager-0.1.0/src/clash_sub_manager/api/routes/_rule_providers.py

@@ -0,0 +1,26 @@
+"""Helpers for rewriting template rule-providers to project-served cached URLs."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from sqlalchemy import select
+
+from ...db.models import RuleSource
+
+if TYPE_CHECKING:
+    from fastapi import Request
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+async def build_cached_rule_provider_urls(db: AsyncSession, request: Request) -> dict[str, str]:
+    sources = list((await db.scalars(select(RuleSource).order_by(RuleSource.id))).all())
+    mappings: dict[str, str] = {}
+    for source in sources:
+        cached_url = str(request.url_for('get_cached_rule_provider', rule_source_id=source.id))
+        mappings[source.name] = cached_url
+        mappings[source.url] = cached_url
+    return mappings
+
+
+__all__ = ['build_cached_rule_provider_urls']

clash_sub_manager-0.1.0/src/clash_sub_manager/api/routes/composite_templates.py

@@ -0,0 +1,204 @@
+"""CRUD endpoints for composed templates."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from ...core import PatchValidationError, TemplateComposer
+from ...db import CompositeTemplate, MergeProfile, Template, TemplatePatch
+from ..dependencies import get_db_session
+from ..schemas import TemplateSummaryRead
+from ..schemas_patch import (
+    CompositePreviewRead,
+    CompositeTemplateCreate,
+    CompositeTemplatePreviewRequest,
+    CompositeTemplateRead,
+    CompositeTemplateUpdate,
+    TemplatePatchSummaryRead,
+)
+from ._db import commit_or_name_conflict
+
+router = APIRouter(tags=['composite-templates'])
+DbSession = Annotated[AsyncSession, Depends(get_db_session)]
+
+
+def _serialize_patch_summary(patch: TemplatePatch) -> TemplatePatchSummaryRead:
+    return TemplatePatchSummaryRead.model_validate(patch)
+
+
+def _serialize_composite_template(composite: CompositeTemplate, patches: list[TemplatePatch]) -> CompositeTemplateRead:
+    return CompositeTemplateRead(
+        id=composite.id,
+        name=composite.name,
+        base_template_id=composite.base_template_id,
+        patch_sequence=list(composite.patch_sequence),
+        cached_content=composite.cached_content,
+        created_at=composite.created_at,
+        updated_at=composite.updated_at,
+        base_template=TemplateSummaryRead.model_validate(composite.base_template),
+        patches=[_serialize_patch_summary(patch) for patch in patches],
+    )
+
+
+async def _get_template_or_404(db: AsyncSession, template_id: int) -> Template:
+    template = await db.get(Template, template_id)
+    if template is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='template not found')
+    return template
+
+
+async def _get_patches_or_404(db: AsyncSession, patch_sequence: list[int]) -> list[TemplatePatch]:
+    if not patch_sequence:
+        return []
+
+    unique_patch_ids = sorted(set(patch_sequence))
+    patches = list((await db.scalars(select(TemplatePatch).where(TemplatePatch.id.in_(unique_patch_ids)))).all())
+    patch_by_id = {patch.id: patch for patch in patches}
+    missing_ids = [patch_id for patch_id in patch_sequence if patch_id not in patch_by_id]
+    if missing_ids:
+        missing = ', '.join(str(patch_id) for patch_id in dict.fromkeys(missing_ids))
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f'template patches not found: {missing}')
+    return [patch_by_id[patch_id] for patch_id in patch_sequence]
+
+
+async def _get_composite_template_or_404(composite_id: int, db: AsyncSession) -> CompositeTemplate:
+    statement = (
+        select(CompositeTemplate)
+        .options(selectinload(CompositeTemplate.base_template))
+        .where(CompositeTemplate.id == composite_id)
+    )
+    composite_template = (await db.scalars(statement)).one_or_none()
+    if composite_template is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='composite template not found')
+    return composite_template
+
+
+async def _render_cached_content(
+    composite_template: CompositeTemplate,
+    db: AsyncSession,
+) -> tuple[str, list[TemplatePatch]]:
+    patches = await _get_patches_or_404(db, composite_template.patch_sequence)
+    try:
+        cached_content = TemplateComposer().render_cached_content(composite_template.base_template, patches)
+    except (PatchValidationError, TypeError, ValueError) as exc:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
+    return cached_content, patches
+
+
+@router.get('/composite-templates', response_model=list[CompositeTemplateRead])
+async def list_composite_templates(db: DbSession) -> list[CompositeTemplateRead]:
+    statement = select(CompositeTemplate).options(selectinload(CompositeTemplate.base_template)).order_by(CompositeTemplate.id)
+    composites = list((await db.scalars(statement)).all())
+
+    changed = False
+    serialized: list[CompositeTemplateRead] = []
+    for composite in composites:
+        cached_content, patches = await _render_cached_content(composite, db)
+        if composite.cached_content != cached_content:
+            composite.cached_content = cached_content
+            changed = True
+        serialized.append(_serialize_composite_template(composite, patches))
+
+    if changed:
+        await db.commit()
+    return serialized
+
+
+@router.post('/composite-templates', response_model=CompositeTemplateRead, status_code=status.HTTP_201_CREATED)
+async def create_composite_template(payload: CompositeTemplateCreate, db: DbSession) -> CompositeTemplateRead:
+    base_template = await _get_template_or_404(db, payload.base_template_id)
+    patches = await _get_patches_or_404(db, payload.patch_sequence)
+
+    try:
+        cached_content = TemplateComposer().render_cached_content(base_template, patches)
+    except (PatchValidationError, TypeError, ValueError) as exc:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
+
+    composite = CompositeTemplate(
+        name=payload.name,
+        base_template_id=payload.base_template_id,
+        patch_sequence=list(payload.patch_sequence),
+        cached_content=cached_content,
+    )
+    composite.base_template = base_template
+    db.add(composite)
+    await commit_or_name_conflict(db, resource_name='composite template', table_name='composite_templates')
+    await db.refresh(composite)
+    return _serialize_composite_template(composite, patches)
+
+
+@router.get('/composite-templates/{composite_id}', response_model=CompositeTemplateRead)
+async def get_composite_template(composite_id: int, db: DbSession) -> CompositeTemplateRead:
+    composite = await _get_composite_template_or_404(composite_id, db)
+    cached_content, patches = await _render_cached_content(composite, db)
+    if composite.cached_content != cached_content:
+        composite.cached_content = cached_content
+        await db.commit()
+        await db.refresh(composite)
+    return _serialize_composite_template(composite, patches)
+
+
+@router.put('/composite-templates/{composite_id}', response_model=CompositeTemplateRead)
+async def update_composite_template(
+    composite_id: int,
+    payload: CompositeTemplateUpdate,
+    db: DbSession,
+) -> CompositeTemplateRead:
+    composite = await _get_composite_template_or_404(composite_id, db)
+
+    name = payload.name if 'name' in payload.model_fields_set and payload.name is not None else composite.name
+    base_template_id = (
+        payload.base_template_id
+        if 'base_template_id' in payload.model_fields_set and payload.base_template_id is not None
+        else composite.base_template_id
+    )
+    patch_sequence = list(payload.patch_sequence) if payload.patch_sequence is not None else list(composite.patch_sequence)
+
+    base_template = await _get_template_or_404(db, base_template_id)
+    patches = await _get_patches_or_404(db, patch_sequence)
+
+    try:
+        cached_content = TemplateComposer().render_cached_content(base_template, patches)
+    except (PatchValidationError, TypeError, ValueError) as exc:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
+
+    composite.name = name
+    composite.base_template_id = base_template_id
+    composite.base_template = base_template
+    composite.patch_sequence = patch_sequence
+    composite.cached_content = cached_content
+
+    await commit_or_name_conflict(db, resource_name='composite template', table_name='composite_templates')
+    await db.refresh(composite)
+    return _serialize_composite_template(composite, patches)
+
+
+@router.delete('/composite-templates/{composite_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def delete_composite_template(composite_id: int, db: DbSession) -> Response:
+    composite = await _get_composite_template_or_404(composite_id, db)
+    merge_profile = await db.scalar(select(MergeProfile.name).where(MergeProfile.composite_template_id == composite_id))
+    if merge_profile is not None:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f'composite template is used by merge profile: {merge_profile}',
+        )
+    await db.delete(composite)
+    await db.commit()
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.post('/composite-templates/preview', response_model=CompositePreviewRead)
+async def preview_composite_template(payload: CompositeTemplatePreviewRequest, db: DbSession) -> CompositePreviewRead:
+    base_template = await _get_template_or_404(db, payload.base_template_id)
+    patches = await _get_patches_or_404(db, payload.patch_sequence)
+
+    try:
+        content = TemplateComposer().render_cached_content(base_template, patches)
+        return CompositePreviewRead(content=content)
+    except (PatchValidationError, TypeError, ValueError) as exc:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc

clash_sub_manager-0.1.0/src/clash_sub_manager/api/routes/config.py

@@ -0,0 +1,172 @@
+"""CRUD endpoints for subscriptions and templates."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ...db.models import CompositeTemplate, Subscription, Template
+from ...models import SubscriptionConfig
+from ..dependencies import get_db_session
+from ..schemas import (
+    SubscriptionCreate,
+    SubscriptionRead,
+    SubscriptionUpdate,
+    TemplateCreate,
+    TemplateRead,
+    TemplateUpdate,
+)
+from ._db import commit_or_name_conflict
+
+router = APIRouter(tags=['config'])
+DbSession = Annotated[AsyncSession, Depends(get_db_session)]
+
+
+async def _ensure_template_exists(db: AsyncSession, template_id: int | None) -> None:
+    if template_id is None:
+        return
+
+    template = await db.get(Template, template_id)
+    if template is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='template not found')
+
+
+@router.get('/subscriptions', response_model=list[SubscriptionRead])
+async def list_subscriptions(db: DbSession) -> list[Subscription]:
+    return list((await db.scalars(select(Subscription).order_by(Subscription.id))).all())
+
+
+@router.post('/subscriptions', response_model=SubscriptionRead, status_code=status.HTTP_201_CREATED)
+async def create_subscription(payload: SubscriptionCreate, db: DbSession) -> Subscription:
+    await _ensure_template_exists(db, payload.template_id)
+    subscription = Subscription(
+        name=payload.name,
+        url=str(payload.url) if payload.url is not None else None,
+        content=payload.content,
+        proxy=payload.proxy,
+        headers=payload.headers,
+        follow_redirects=payload.follow_redirects,
+        enabled=payload.enabled,
+        template_id=payload.template_id,
+    )
+    db.add(subscription)
+    await commit_or_name_conflict(db, resource_name='subscription', table_name='subscriptions')
+    await db.refresh(subscription)
+    return subscription
+
+
+@router.get('/subscriptions/{subscription_id}', response_model=SubscriptionRead)
+async def get_subscription(subscription_id: int, db: DbSession) -> Subscription:
+    subscription = await db.get(Subscription, subscription_id)
+    if subscription is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='subscription not found')
+    return subscription
+
+
+@router.put('/subscriptions/{subscription_id}', response_model=SubscriptionRead)
+async def update_subscription(subscription_id: int, payload: SubscriptionUpdate, db: DbSession) -> Subscription:
+    subscription = await db.get(Subscription, subscription_id)
+    if subscription is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='subscription not found')
+
+    current = {
+        'name': subscription.name,
+        'url': subscription.url,
+        'content': subscription.content,
+        'proxy': subscription.proxy,
+        'headers': subscription.headers,
+        'follow_redirects': subscription.follow_redirects,
+        'enabled': subscription.enabled,
+        'template_id': subscription.template_id,
+    }
+    updated = payload.model_dump(exclude_unset=True)
+    merged = current | updated
+    SubscriptionConfig.model_validate(
+        {
+            'name': merged['name'],
+            'url': merged['url'],
+            'content': merged['content'],
+            'proxy': merged['proxy'],
+            'headers': merged['headers'],
+            'follow_redirects': merged['follow_redirects'],
+            'enabled': merged['enabled'],
+        }
+    )
+    await _ensure_template_exists(db, merged['template_id'])
+
+    for field, value in merged.items():
+        if field == 'url' and value is not None:
+            setattr(subscription, field, str(value))
+        else:
+            setattr(subscription, field, value)
+
+    await commit_or_name_conflict(db, resource_name='subscription', table_name='subscriptions')
+    await db.refresh(subscription)
+    return subscription
+
+
+@router.delete('/subscriptions/{subscription_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def delete_subscription(subscription_id: int, db: DbSession) -> Response:
+    subscription = await db.get(Subscription, subscription_id)
+    if subscription is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='subscription not found')
+    await db.delete(subscription)
+    await db.commit()
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.get('/templates', response_model=list[TemplateRead])
+async def list_templates(db: DbSession) -> list[Template]:
+    return list((await db.scalars(select(Template).order_by(Template.id))).all())
+
+
+@router.post('/templates', response_model=TemplateRead, status_code=status.HTTP_201_CREATED)
+async def create_template(payload: TemplateCreate, db: DbSession) -> Template:
+    template = Template(name=payload.name, content=payload.content, is_default=payload.is_default)
+    db.add(template)
+    await commit_or_name_conflict(db, resource_name='template', table_name='templates')
+    await db.refresh(template)
+    return template
+
+
+@router.get('/templates/{template_id}', response_model=TemplateRead)
+async def get_template(template_id: int, db: DbSession) -> Template:
+    template = await db.get(Template, template_id)
+    if template is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='template not found')
+    return template
+
+
+@router.put('/templates/{template_id}', response_model=TemplateRead)
+async def update_template(template_id: int, payload: TemplateUpdate, db: DbSession) -> Template:
+    template = await db.get(Template, template_id)
+    if template is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='template not found')
+    for field, value in payload.model_dump(exclude_unset=True).items():
+        setattr(template, field, value)
+    await commit_or_name_conflict(db, resource_name='template', table_name='templates')
+    await db.refresh(template)
+    return template
+
+
+@router.delete('/templates/{template_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def delete_template(template_id: int, db: DbSession) -> Response:
+    template = await db.get(Template, template_id)
+    if template is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='template not found')
+
+    composite_template = await db.scalar(
+        select(CompositeTemplate.id).where(CompositeTemplate.base_template_id == template_id)
+    )
+    if composite_template is not None:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='template is used by a composite template',
+        )
+
+    await db.delete(template)
+    await db.commit()
+    return Response(status_code=status.HTTP_204_NO_CONTENT)