json-admin 0.1.0__tar.gz

json_admin-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, LoveBloodAndDiamonds
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

json_admin-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: json-admin
+Version: 0.1.0
+Summary: Simple web admin interface to manage .json file
+Author-email: LoveBloodAndDiamonds <ayazshakirzyanov27@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2025, LoveBloodAndDiamonds
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Github, https://github.com/LoveBloodAndDiamonds/json-admin
+Project-URL: Author, https://t.me/LoveBloodAndDiamonds
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: litestar>=2.18.0
+Requires-Dist: pydantic>=2.11.0
+Requires-Dist: uvicorn>=0.41.0
+Dynamic: license-file
+
+# Json-admin
+
+Библиотека с реализацией простого интерфейса для управления .json-файлом с настройками приложения.
+
+## Быстрый старт
+
+```python
+from litestar import Litestar
+from pydantic import BaseModel, Field
+
+from jsonadmin import Admin, HtmlPage, JsonPage
+
+
+class AppSettings(BaseModel):
+    """Настройки приложения."""
+
+    debug: bool = Field(default=False, description="Включает debug-режим")
+    retries: int = Field(default=3, ge=0, description="Количество повторных попыток")
+
+
+class FeatureFlags(BaseModel):
+    """Настройки feature flags."""
+
+    use_cache: bool = Field(default=True, description="Включает кеширование")
+    beta_mode: bool = Field(default=False, description="Включает beta-режим")
+
+
+app = Litestar(route_handlers=[])
+admin = Admin(
+    app=app,
+    passwd="super-strong-password",
+    title="My App Admin",
+    index="index.html",
+    login="login.html",
+    pages=[
+        HtmlPage(
+            slug="info",
+            title="Информация",
+            icon="fa-solid fa-circle-info",
+            content="""
+            <h2>Welcome</h2>
+            <p>This page is read-only and renders embedded HTML block.</p>
+            """,
+        ),
+        JsonPage(
+            slug="settings",
+            title="Настройки",
+            file_path="data/app_settings.json",
+            model=AppSettings,
+            icon="fa-solid fa-gear",
+        ),
+        JsonPage(
+            slug="features",
+            title="Флаги",
+            file_path="data/feature_flags.json",
+            model=FeatureFlags,
+            icon="fa-solid fa-flag",
+        ),
+    ],
+    base_url="/",
+)
+```
+
+После запуска:
+- `GET /` покажет форму входа по паролю.
+- после входа доступны вкладки-страницы с JSON-редактором.
+- `HtmlPage` — read-only вкладка с HTML-блоком. `content` может быть:
+  - встроенной строкой HTML,
+  - путём к `.html` файлу,
+  - `Callable[[], str]`.
+- кнопка `Сохранить` валидирует данные через обязательную Pydantic-модель и сохраняет JSON в файл.
+- можно переопределить интерфейс через Jinja-шаблоны в `jsonadmin/html/` (по умолчанию) или через `templates_dir=...`.
+- для вкладок можно передать `icon` с классом Font Awesome, например `fa-solid fa-gear`.

json_admin-0.1.0/README.md

@@ -0,0 +1,73 @@
+# Json-admin
+
+Библиотека с реализацией простого интерфейса для управления .json-файлом с настройками приложения.
+
+## Быстрый старт
+
+```python
+from litestar import Litestar
+from pydantic import BaseModel, Field
+
+from jsonadmin import Admin, HtmlPage, JsonPage
+
+
+class AppSettings(BaseModel):
+    """Настройки приложения."""
+
+    debug: bool = Field(default=False, description="Включает debug-режим")
+    retries: int = Field(default=3, ge=0, description="Количество повторных попыток")
+
+
+class FeatureFlags(BaseModel):
+    """Настройки feature flags."""
+
+    use_cache: bool = Field(default=True, description="Включает кеширование")
+    beta_mode: bool = Field(default=False, description="Включает beta-режим")
+
+
+app = Litestar(route_handlers=[])
+admin = Admin(
+    app=app,
+    passwd="super-strong-password",
+    title="My App Admin",
+    index="index.html",
+    login="login.html",
+    pages=[
+        HtmlPage(
+            slug="info",
+            title="Информация",
+            icon="fa-solid fa-circle-info",
+            content="""
+            <h2>Welcome</h2>
+            <p>This page is read-only and renders embedded HTML block.</p>
+            """,
+        ),
+        JsonPage(
+            slug="settings",
+            title="Настройки",
+            file_path="data/app_settings.json",
+            model=AppSettings,
+            icon="fa-solid fa-gear",
+        ),
+        JsonPage(
+            slug="features",
+            title="Флаги",
+            file_path="data/feature_flags.json",
+            model=FeatureFlags,
+            icon="fa-solid fa-flag",
+        ),
+    ],
+    base_url="/",
+)
+```
+
+После запуска:
+- `GET /` покажет форму входа по паролю.
+- после входа доступны вкладки-страницы с JSON-редактором.
+- `HtmlPage` — read-only вкладка с HTML-блоком. `content` может быть:
+  - встроенной строкой HTML,
+  - путём к `.html` файлу,
+  - `Callable[[], str]`.
+- кнопка `Сохранить` валидирует данные через обязательную Pydantic-модель и сохраняет JSON в файл.
+- можно переопределить интерфейс через Jinja-шаблоны в `jsonadmin/html/` (по умолчанию) или через `templates_dir=...`.
+- для вкладок можно передать `icon` с классом Font Awesome, например `fa-solid fa-gear`.

json_admin-0.1.0/json_admin.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: json-admin
+Version: 0.1.0
+Summary: Simple web admin interface to manage .json file
+Author-email: LoveBloodAndDiamonds <ayazshakirzyanov27@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2025, LoveBloodAndDiamonds
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Github, https://github.com/LoveBloodAndDiamonds/json-admin
+Project-URL: Author, https://t.me/LoveBloodAndDiamonds
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: litestar>=2.18.0
+Requires-Dist: pydantic>=2.11.0
+Requires-Dist: uvicorn>=0.41.0
+Dynamic: license-file
+
+# Json-admin
+
+Библиотека с реализацией простого интерфейса для управления .json-файлом с настройками приложения.
+
+## Быстрый старт
+
+```python
+from litestar import Litestar
+from pydantic import BaseModel, Field
+
+from jsonadmin import Admin, HtmlPage, JsonPage
+
+
+class AppSettings(BaseModel):
+    """Настройки приложения."""
+
+    debug: bool = Field(default=False, description="Включает debug-режим")
+    retries: int = Field(default=3, ge=0, description="Количество повторных попыток")
+
+
+class FeatureFlags(BaseModel):
+    """Настройки feature flags."""
+
+    use_cache: bool = Field(default=True, description="Включает кеширование")
+    beta_mode: bool = Field(default=False, description="Включает beta-режим")
+
+
+app = Litestar(route_handlers=[])
+admin = Admin(
+    app=app,
+    passwd="super-strong-password",
+    title="My App Admin",
+    index="index.html",
+    login="login.html",
+    pages=[
+        HtmlPage(
+            slug="info",
+            title="Информация",
+            icon="fa-solid fa-circle-info",
+            content="""
+            <h2>Welcome</h2>
+            <p>This page is read-only and renders embedded HTML block.</p>
+            """,
+        ),
+        JsonPage(
+            slug="settings",
+            title="Настройки",
+            file_path="data/app_settings.json",
+            model=AppSettings,
+            icon="fa-solid fa-gear",
+        ),
+        JsonPage(
+            slug="features",
+            title="Флаги",
+            file_path="data/feature_flags.json",
+            model=FeatureFlags,
+            icon="fa-solid fa-flag",
+        ),
+    ],
+    base_url="/",
+)
+```
+
+После запуска:
+- `GET /` покажет форму входа по паролю.
+- после входа доступны вкладки-страницы с JSON-редактором.
+- `HtmlPage` — read-only вкладка с HTML-блоком. `content` может быть:
+  - встроенной строкой HTML,
+  - путём к `.html` файлу,
+  - `Callable[[], str]`.
+- кнопка `Сохранить` валидирует данные через обязательную Pydantic-модель и сохраняет JSON в файл.
+- можно переопределить интерфейс через Jinja-шаблоны в `jsonadmin/html/` (по умолчанию) или через `templates_dir=...`.
+- для вкладок можно передать `icon` с классом Font Awesome, например `fa-solid fa-gear`.

json_admin-0.1.0/json_admin.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+json_admin.egg-info/PKG-INFO
+json_admin.egg-info/SOURCES.txt
+json_admin.egg-info/dependency_links.txt
+json_admin.egg-info/requires.txt
+json_admin.egg-info/top_level.txt
+jsonadmin/__init__.py
+jsonadmin/admin.py
+jsonadmin/pages.py

json_admin-0.1.0/json_admin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

json_admin-0.1.0/json_admin.egg-info/requires.txt

@@ -0,0 +1,4 @@
+jinja2>=3.1.6
+litestar>=2.18.0
+pydantic>=2.11.0
+uvicorn>=0.41.0

json_admin-0.1.0/json_admin.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsonadmin

json_admin-0.1.0/jsonadmin/__init__.py

@@ -0,0 +1,6 @@
+"""Публичный API библиотеки json-admin."""
+
+from jsonadmin.admin import Admin
+from jsonadmin.pages import BasePage, HtmlPage, JsonPage
+
+__all__ = ["Admin", "BasePage", "JsonPage", "HtmlPage"]

json_admin-0.1.0/jsonadmin/admin.py

@@ -0,0 +1,707 @@
+"""Минимальная админка для редактирования JSON-файлов на Litestar."""
+
+import asyncio
+import hashlib
+import hmac
+import json
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, TemplateNotFound, select_autoescape
+from litestar import Litestar, Request, Response, get, post
+from litestar.datastructures import Cookie
+from pydantic import BaseModel
+
+from jsonadmin.pages import BasePage, HtmlPage, JsonPage
+
+
+class Admin:
+    """Управляет JSON-страницами и авторизацией по единому паролю."""
+
+    def __init__(
+        self,
+        app: Litestar,
+        passwd: str,
+        pages: list[BasePage] | None = None,
+        title: str = "JSON Admin",
+        templates_dir: str | Path | None = None,
+        index: str = "index.html",
+        login: str = "login.html",
+        base_url: str = "/",
+    ) -> None:
+        """Инициализирует админ-панель и регистрирует маршруты.
+
+        Args:
+            app: Экземпляр Litestar-приложения.
+            passwd: Пароль для входа в админку.
+            pages: Список вкладок админки.
+            title: Название приложения в интерфейсе админки.
+            templates_dir: Директория с пользовательскими HTML-шаблонами. По умолчанию используется `jsonadmin/html`.
+            index: Имя шаблона страницы редактора.
+            login: Имя шаблона страницы входа.
+            base_url: Базовый URL, на котором будет доступна админка.
+
+        """
+        self._app: Litestar = app
+        self._passwd: str = passwd
+        self._title: str = title
+        self._base_url: str = self._normalize_base_url(base_url)
+        if templates_dir is None:
+            self._templates_dir = Path(__file__).resolve().parent / "html"
+        else:
+            self._templates_dir = Path(templates_dir)
+        self._index_template: str = index
+        self._login_template: str = login
+        self._template_env: Environment | None = self._init_template_env(self._templates_dir)
+        self._cookie_name: str = "jsonadmin_session"
+        self._pages: dict[str, BasePage] = {}
+        self._token_secret: str = hashlib.sha256(passwd.encode("utf-8")).hexdigest()
+        self._register_routes()
+
+        for page in pages or []:
+            self.add_page(page)
+
+    def add_page(self, page: BasePage) -> None:
+        """Регистрирует новую вкладку админки.
+
+        Args:
+            page: Описание страницы админки.
+
+        Raises:
+            ValueError: Если slug уже занят.
+
+        """
+        if page.slug in self._pages:
+            raise ValueError(f"Page with slug='{page.slug}' is already registered")
+        self._pages[page.slug] = page
+
+    def _register_routes(self) -> None:
+        """Добавляет маршруты админки в Litestar-приложение."""
+
+        @get(path=self._route(""))
+        async def index(request: Request[Any, Any, Any]) -> Response[str]:
+            """Отображает главную страницу или форму входа.
+
+            Args:
+                request: Входящий HTTP-запрос.
+
+            Returns:
+                Response[str]: HTML-ответ.
+
+            """
+            if not self._is_authorized(request):
+                return self._login_page(error_text="")
+
+            if not self._pages:
+                return self._html_response(f"<h1>{self._title}</h1><p>No registered pages.</p>")
+
+            first_slug = next(iter(self._pages))
+            return self._redirect(self._route(f"/page/{first_slug}"))
+
+        @post(path=self._route("/login"))
+        async def login(request: Request[Any, Any, Any]) -> Response[str]:
+            """Проверяет пароль и устанавливает сессионную cookie.
+
+            Args:
+                request: Входящий HTTP-запрос.
+
+            Returns:
+                Response[str]: Редирект на страницу админки или форма с ошибкой.
+
+            """
+            form = await request.form()
+            input_passwd = str(form.get("passwd", ""))
+            if not hmac.compare_digest(input_passwd, self._passwd):
+                return self._login_page(error_text="Invalid password")
+
+            response = self._redirect(self._route(""))
+            response.set_cookie(self._auth_cookie())
+            return response
+
+        @post(path=self._route("/logout"))
+        async def logout() -> Response[str]:
+            """Удаляет сессионную cookie и завершает сессию.
+
+            Returns:
+                Response[str]: Редирект на форму входа.
+
+            """
+            response = self._redirect(self._route(""))
+            response.delete_cookie(key=self._cookie_name, path=self._route(""))
+            return response
+
+        @get(path=self._route("/page/{slug:str}"))
+        async def page_view(request: Request[Any, Any, Any], slug: str) -> Response[str]:
+            """Показывает страницу редактирования JSON.
+
+            Args:
+                request: Входящий HTTP-запрос.
+                slug: Идентификатор страницы.
+
+            Returns:
+                Response[str]: HTML страницы редактора.
+
+            """
+            if not self._is_authorized(request):
+                return self._redirect(self._route(""))
+
+            page = self._pages.get(slug)
+            if page is None:
+                return self._html_response("<h1>404</h1><p>Page not found</p>", status_code=404)
+
+            if isinstance(page, HtmlPage):
+                html_content = await self._resolve_html_page_content(page)
+                return self._html_page(page=page, content_html=html_content, error_text="")
+            if not isinstance(page, JsonPage):
+                return self._html_response(
+                    "<h1>500</h1><p>Unsupported page type</p>", status_code=500
+                )
+
+            payload, load_error = await self._read_json_payload(page.path)
+            pretty_json = json.dumps(payload, ensure_ascii=False, indent=2)
+            schema_text = self._build_schema_text(page.model)
+            return self._editor_page(
+                page=page, json_text=pretty_json, schema_text=schema_text, error_text=load_error
+            )
+
+        @post(path=self._route("/page/{slug:str}"))
+        async def save_page(request: Request[Any, Any, Any], slug: str) -> Response[str]:
+            """Сохраняет JSON после валидации.
+
+            Args:
+                request: Входящий HTTP-запрос.
+                slug: Идентификатор страницы.
+
+            Returns:
+                Response[str]: HTML страницы редактора с результатом операции.
+
+            """
+            if not self._is_authorized(request):
+                return self._redirect(self._route(""))
+
+            page = self._pages.get(slug)
+            if page is None:
+                return self._html_response("<h1>404</h1><p>Page not found</p>", status_code=404)
+
+            if isinstance(page, HtmlPage):
+                html_content = await self._resolve_html_page_content(page)
+                return self._html_page(
+                    page=page,
+                    content_html=html_content,
+                    error_text="HtmlPage is read-only.",
+                    status_code=405,
+                )
+            if not isinstance(page, JsonPage):
+                return self._html_response(
+                    "<h1>500</h1><p>Unsupported page type</p>", status_code=500
+                )
+
+            form = await request.form()
+            json_text = str(form.get("payload", ""))
+
+            try:
+                raw_payload = json.loads(json_text)
+            except json.JSONDecodeError as exc:
+                schema_text = self._build_schema_text(page.model)
+                return self._editor_page(
+                    page=page,
+                    json_text=json_text,
+                    schema_text=schema_text,
+                    error_text=f"JSON error: {exc}",
+                )
+
+            try:
+                saved_payload = page.validate_payload(raw_payload)
+            except Exception as exc:  # noqa: BLE001
+                schema_text = self._build_schema_text(page.model)
+                return self._editor_page(
+                    page=page,
+                    json_text=json_text,
+                    schema_text=schema_text,
+                    error_text=f"Model validation error: {exc}",
+                )
+
+            await self._write_json_payload(page.path, saved_payload)
+            pretty_json = json.dumps(saved_payload, ensure_ascii=False, indent=2)
+            schema_text = self._build_schema_text(page.model)
+            return self._editor_page(
+                page=page,
+                json_text=pretty_json,
+                schema_text=schema_text,
+                error_text="",
+                success_text="Изменения сохранены",
+            )
+
+        # Регистрируем обработчики в Litestar-приложении.
+        for handler in (index, login, logout, page_view, save_page):
+            self._app.register(handler)
+
+    def _init_template_env(self, templates_dir: Path) -> Environment | None:
+        """Создает Jinja-окружение для HTML-шаблонов.
+
+        Args:
+            templates_dir: Директория с шаблонами.
+
+        Returns:
+            Environment | None: Настроенное окружение или `None`, если директории нет.
+
+        """
+        if not templates_dir.exists() or not templates_dir.is_dir():
+            return None
+
+        return Environment(
+            loader=FileSystemLoader(str(templates_dir)),
+            autoescape=select_autoescape(enabled_extensions=("html", "htm")),
+        )
+
+    def _build_nav_pages(self, active_slug: str) -> list[dict[str, str | bool]]:
+        """Собирает список вкладок для навигации.
+
+        Args:
+            active_slug: Slug текущей активной страницы.
+
+        Returns:
+            list[dict[str, str | bool]]: Данные вкладок для шаблона.
+
+        """
+        nav_pages: list[dict[str, str | bool]] = []
+        for nav_page in self._pages.values():
+            nav_pages.append(  # noqa
+                {
+                    "slug": nav_page.slug,
+                    "title": nav_page.title,
+                    "icon": nav_page.icon,
+                    "href": self._route(f"/page/{nav_page.slug}"),
+                    "active": nav_page.slug == active_slug,
+                }
+            )
+        return nav_pages
+
+    async def _resolve_html_page_content(self, page: HtmlPage) -> str:
+        """Получает HTML-контент для HtmlPage.
+
+        Args:
+            page: Конфигурация HTML-вкладки.
+
+        Returns:
+            str: Готовый HTML-блок.
+
+        """
+        content = page.content
+        if callable(content):
+
+            def _call() -> str:
+                return content()
+
+            rendered = await asyncio.to_thread(_call)
+            return str(rendered)
+
+        if isinstance(content, Path):
+            return await asyncio.to_thread(content.read_text, "utf-8")
+
+        possible_path = Path(content)
+        if possible_path.suffix.lower() in {".html", ".htm"} and possible_path.exists():
+            return await asyncio.to_thread(possible_path.read_text, "utf-8")
+
+        return content
+
+    def _render_editor_template(
+        self,
+        page: BasePage,
+        json_text: str,
+        schema_text: str,
+        error_text: str,
+        success_text: str,
+        content_html: str = "",
+        save_action: str = "",
+    ) -> str | None:
+        """Рендерит пользовательский HTML-шаблон editor-страницы.
+
+        Args:
+            page: Активная страница.
+            json_text: Содержимое JSON в textarea.
+            schema_text: JSON-схема модели.
+            error_text: Сообщение об ошибке.
+            success_text: Сообщение об успехе.
+            content_html: Контент HtmlPage для встраивания в основной блок.
+            save_action: URL для сохранения JsonPage.
+
+        Returns:
+            str | None: HTML-контент или `None`, если шаблоны недоступны.
+
+        """
+        if self._template_env is None:
+            return None
+
+        try:
+            template = self._template_env.get_template(self._index_template)
+        except TemplateNotFound:
+            return None
+
+        return template.render(
+            app_title=self._title,
+            page_title=page.title,
+            nav_pages=self._build_nav_pages(active_slug=page.slug),
+            save_action=save_action,
+            logout_action=self._route("/logout"),
+            payload=json_text,
+            schema_text=schema_text,
+            error_text=error_text,
+            success_text=success_text,
+            content_html=content_html,
+        )
+
+    def _render_login_template(self, error_text: str) -> str | None:
+        """Рендерит пользовательский HTML-шаблон страницы входа.
+
+        Args:
+            error_text: Сообщение об ошибке входа.
+
+        Returns:
+            str | None: HTML-контент или `None`, если шаблоны недоступны.
+
+        """
+        if self._template_env is None:
+            return None
+
+        try:
+            template = self._template_env.get_template(self._login_template)
+        except TemplateNotFound:
+            return None
+
+        return template.render(
+            app_title=self._title,
+            page_title="Login",
+            login_action=self._route("/login"),
+            error_text=error_text,
+        )
+
+    def _normalize_base_url(self, base_url: str) -> str:
+        """Нормализует базовый URL для стабильного роутинга.
+
+        Args:
+            base_url: Исходный URL.
+
+        Returns:
+            str: Нормализованный путь, начинающийся с `/`.
+
+        """
+        if not base_url:
+            return "/"
+
+        if not base_url.startswith("/"):
+            base_url = f"/{base_url}"
+
+        if len(base_url) > 1 and base_url.endswith("/"):
+            base_url = base_url[:-1]
+
+        return base_url
+
+    def _route(self, suffix: str) -> str:
+        """Строит конечный путь маршрута.
+
+        Args:
+            suffix: Дополнение к базовому URL.
+
+        Returns:
+            str: Полный маршрут.
+
+        """
+        suffix = suffix or ""
+        if suffix and not suffix.startswith("/"):
+            suffix = f"/{suffix}"
+
+        if self._base_url == "/":
+            return suffix or "/"
+
+        return f"{self._base_url}{suffix}"
+
+    def _make_session_token(self) -> str:
+        """Создает подпись текущей сессии на основе пароля.
+
+        Returns:
+            str: Токен сессионной cookie.
+
+        """
+        return hmac.new(
+            key=self._token_secret.encode("utf-8"),
+            msg=b"jsonadmin-authenticated",
+            digestmod=hashlib.sha256,
+        ).hexdigest()
+
+    def _is_authorized(self, request: Request[Any, Any, Any]) -> bool:
+        """Проверяет валидность cookie авторизации.
+
+        Args:
+            request: Входящий HTTP-запрос.
+
+        Returns:
+            bool: `True`, если сессия подтверждена.
+
+        """
+        cookie = request.cookies.get(self._cookie_name)
+        if not cookie:
+            return False
+        return hmac.compare_digest(cookie, self._make_session_token())
+
+    def _auth_cookie(self) -> Cookie:
+        """Создает защищенную cookie после успешного входа.
+
+        Returns:
+            Cookie: Конфигурация cookie авторизации.
+
+        """
+        return Cookie(
+            key=self._cookie_name,
+            value=self._make_session_token(),
+            httponly=True,
+            secure=False,
+            samesite="strict",
+            path=self._route(""),
+        )
+
+    async def _read_json_payload(self, file_path: Path) -> tuple[Any, str]:
+        """Читает JSON-файл и возвращает данные либо ошибку.
+
+        Args:
+            file_path: Путь до файла.
+
+        Returns:
+            tuple[Any, str]: Распарсенные данные и текст ошибки.
+
+        """
+        if not file_path.exists():
+            return {}, ""
+
+        def _read_text() -> str:
+            return file_path.read_text(encoding="utf-8")
+
+        text = await asyncio.to_thread(_read_text)
+        if not text.strip():
+            return {}, ""
+
+        try:
+            return json.loads(text), ""
+        except json.JSONDecodeError as exc:
+            return {}, f"File contains invalid JSON: {exc}"
+
+    async def _write_json_payload(self, file_path: Path, payload: Any) -> None:
+        """Сохраняет JSON в файл в читаемом формате.
+
+        Args:
+            file_path: Путь до файла.
+            payload: Данные для сериализации.
+
+        """
+        json_text = json.dumps(payload, ensure_ascii=False, indent=2)
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        def _write_text() -> None:
+            file_path.write_text(json_text, encoding="utf-8")
+
+        await asyncio.to_thread(_write_text)
+
+    def _build_schema_text(self, model: type[BaseModel]) -> str:
+        """Формирует текст JSON-схемы из Pydantic-модели.
+
+        Args:
+            model: Модель страницы.
+
+        Returns:
+            str: Схема или пустая строка.
+
+        """
+        schema = model.model_json_schema()
+        return json.dumps(schema, ensure_ascii=False, indent=2)
+
+    def _login_page(self, error_text: str) -> Response[str]:
+        """Строит HTML формы входа.
+
+        Args:
+            error_text: Сообщение об ошибке авторизации.
+
+        Returns:
+            Response[str]: HTML-ответ.
+
+        """
+        rendered_html = self._render_login_template(error_text=error_text)
+        if rendered_html is not None:
+            return self._html_response(rendered_html)
+
+        error_html = f"<p>{error_text}</p>" if error_text else ""
+        html = f"""
+<!doctype html>
+<html lang="ru">
+<head><meta charset="utf-8"><title>Вход</title></head>
+<body>
+  <h1>{self._title}</h1>
+  {error_html}
+  <form method="post" action="{self._route("/login")}">
+    <label for="passwd">Password</label><br>
+    <input id="passwd" name="passwd" type="password" required autofocus><br><br>
+    <button type="submit">Sign in</button>
+  </form>
+</body>
+</html>
+"""
+        return self._html_response(html)
+
+    def _editor_page(
+        self,
+        page: JsonPage,
+        json_text: str,
+        schema_text: str,
+        error_text: str,
+        success_text: str = "",
+    ) -> Response[str]:
+        """Строит HTML-страницу редактирования JSON.
+
+        Args:
+            page: Конфигурация активной вкладки.
+            json_text: Текущий JSON для textarea.
+            schema_text: JSON-схема модели для показа.
+            error_text: Read or save error message.
+            success_text: Сообщение об успешном сохранении.
+
+        Returns:
+            Response[str]: HTML-ответ страницы.
+
+        """
+        rendered_html = self._render_editor_template(
+            page=page,
+            json_text=json_text,
+            schema_text=schema_text,
+            error_text=error_text,
+            success_text=success_text,
+            save_action=self._route(f"/page/{page.slug}"),
+        )
+        if rendered_html is not None:
+            return self._html_response(rendered_html)
+
+        nav_parts: list[str] = []
+        for nav_page in self._pages.values():
+            icon_html = f'<i class="{nav_page.icon}"></i> ' if nav_page.icon else ""
+            if nav_page.slug == page.slug:
+                nav_parts.append(f"<b>{icon_html}{nav_page.title}</b>")
+            else:
+                nav_parts.append(
+                    f'<a href="{self._route(f"/page/{nav_page.slug}")}">{icon_html}{nav_page.title}</a>'
+                )
+
+        nav_html = " | ".join(nav_parts)
+        error_html = f"<p>{error_text}</p>" if error_text else ""
+        success_html = f"<p>{success_text}</p>" if success_text else ""
+        schema_html = f"<h3>Схема модели</h3><pre>{schema_text}</pre>" if schema_text else ""
+
+        html = f"""
+<!doctype html>
+<html lang="ru">
+<head><meta charset="utf-8"><title>{page.title}</title></head>
+<body>
+  <h1>{self._title}</h1>
+  <p>{nav_html}</p>
+  <form method="post" action="{self._route(f"/page/{page.slug}")}">
+    <h2>{page.title}</h2>
+    {error_html}
+    {success_html}
+    <textarea name="payload" rows="30" cols="120">{json_text}</textarea><br><br>
+    <button type="submit">Сохранить</button>
+  </form>
+  <form method="post" action="{self._route("/logout")}">
+    <button type="submit">Выйти</button>
+  </form>
+  {schema_html}
+</body>
+</html>
+"""
+        return self._html_response(html)
+
+    def _html_page(
+        self,
+        page: HtmlPage,
+        content_html: str,
+        error_text: str,
+        status_code: int = 200,
+    ) -> Response[str]:
+        """Строит read-only страницу HtmlPage.
+
+        Args:
+            page: Активная HTML-вкладка.
+            content_html: HTML-блок страницы.
+            error_text: Сообщение об ошибке.
+            status_code: HTTP-статус ответа.
+
+        Returns:
+            Response[str]: HTML-ответ страницы.
+
+        """
+        rendered_html = self._render_editor_template(
+            page=page,
+            json_text="",
+            schema_text="",
+            error_text=error_text,
+            success_text="",
+            content_html=content_html,
+            save_action="",
+        )
+        if rendered_html is not None:
+            return self._html_response(rendered_html, status_code=status_code)
+
+        nav_parts: list[str] = []
+        for nav_page in self._pages.values():
+            icon_html = f'<i class="{nav_page.icon}"></i> ' if nav_page.icon else ""
+            if nav_page.slug == page.slug:
+                nav_parts.append(f"<b>{icon_html}{nav_page.title}</b>")
+            else:
+                nav_parts.append(
+                    f'<a href="{self._route(f"/page/{nav_page.slug}")}">{icon_html}{nav_page.title}</a>'
+                )
+
+        nav_html = " | ".join(nav_parts)
+        error_html = f"<p>{error_text}</p>" if error_text else ""
+
+        html = f"""
+<!doctype html>
+<html lang="ru">
+<head><meta charset="utf-8"><title>{page.title}</title></head>
+<body>
+  <h1>{self._title}</h1>
+  <p>{nav_html}</p>
+  {error_html}
+  <div>{content_html}</div>
+  <form method="post" action="{self._route("/logout")}">
+    <button type="submit">Out</button>
+  </form>
+</body>
+</html>
+"""
+        return self._html_response(html, status_code=status_code)
+
+    def _html_response(self, content: str, status_code: int = 200) -> Response[str]:
+        """Создает HTML-ответ с едиными заголовками.
+
+        Args:
+            content: Тело HTML-страницы.
+            status_code: HTTP-код ответа.
+
+        Returns:
+            Response[str]: Готовый HTTP-ответ.
+
+        """
+        return Response(
+            content=content,
+            media_type="text/html; charset=utf-8",
+            status_code=status_code,
+        )
+
+    def _redirect(self, location: str) -> Response[str]:
+        """Создает HTTP-редирект.
+
+        Args:
+            location: URL для перехода.
+
+        Returns:
+            Response[str]: Ответ с кодом 303.
+
+        """
+        return Response(content="", status_code=303, headers={"Location": location})

json_admin-0.1.0/jsonadmin/pages.py

@@ -0,0 +1,72 @@
+"""Модели страниц для админки."""
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BasePage(BaseModel):
+    """Общая модель страницы админки.
+
+    Attributes:
+        slug: Уникальный идентификатор страницы для URL.
+        title: Заголовок вкладки в интерфейсе.
+        icon: CSS-класс иконки (например, `fa-solid fa-gear`).
+
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    slug: str = Field(min_length=1)
+    title: str = Field(min_length=1)
+    icon: str = ""
+
+
+class JsonPage(BasePage):
+    """Конфигурация вкладки редактирования JSON.
+
+    Attributes:
+        file_path: Путь до JSON-файла.
+        model: Pydantic-модель для валидации содержимого.
+
+    """
+
+    file_path: str | Path
+    model: type[BaseModel]
+
+    @property
+    def path(self) -> Path:
+        """Возвращает путь к JSON-файлу как Path."""
+        return Path(self.file_path)
+
+    def validate_payload(self, payload: Any) -> Any:
+        """Проверяет JSON через модель страницы.
+
+        Args:
+            payload: Данные, распарсенные из JSON.
+
+        Returns:
+            Any: Проверенные данные для сохранения.
+
+        """
+        validated = self.model.model_validate(payload)
+        return validated.model_dump(mode="json")
+
+
+class HtmlPage(BasePage):
+    """Конфигурация read-only HTML вкладки.
+
+    Attributes:
+        content: Контент вкладки.
+            Поддерживается:
+            - str (встроенный HTML),
+            - str/Path к .html файлу,
+            - Callable[[], str] для динамической генерации.
+
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid", arbitrary_types_allowed=True)
+
+    content: str | Path | Callable[[], str]

json_admin-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "json-admin"
+
+# •	PATCH (x.y.Z) → увеличивается при багфиксе, который не ломает совместимость.
+# •	MINOR (x.Y.z) → увеличивается при добавлении новой функциональности, но без ломающих изменений (backward-compatible).
+# •	MAJOR (X.y.z) → увеличивается при изменениях, которые ломают обратную совместимость.
+version = "0.1.0"
+
+description = "Simple web admin interface to manage .json file"
+readme = "README.md"
+license = {file = "LICENSE"}
+authors = [
+  { name = "LoveBloodAndDiamonds", email = "ayazshakirzyanov27@gmail.com" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "jinja2>=3.1.6",
+    "litestar>=2.18.0",
+    "pydantic>=2.11.0",
+    "uvicorn>=0.41.0",
+]
+[dependency-groups]
+dev = [
+    "build>=1.3.0",
+    "pre-commit>=4.3.0",
+    "twine>=6.2.0",
+]
+[project.urls]
+Github = "https://github.com/LoveBloodAndDiamonds/json-admin"
+Author = "https://t.me/LoveBloodAndDiamonds"

json_admin-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+