uEdition-Editor 2.0.0b3__py3-none-any.whl → 2.0.0b5__py3-none-any.whl

uedition_editor/__about__.py

@@ -3,4 +3,4 @@
 # SPDX-License-Identifier: MIT
 """About this package."""
 
-__version__ = "2.0.0b3"
+__version__ = "2.0.0b5"

uedition_editor/__init__.py

@@ -4,16 +4,31 @@
 """The main uEditor server."""
 
 import logging
+from copy import deepcopy
 
 from fastapi import FastAPI
 from fastapi.responses import RedirectResponse
 from fastapi.staticfiles import StaticFiles
+from uvicorn.config import LOGGING_CONFIG
 
+from uedition_editor import cron  # noqa:F401
 from uedition_editor.api import router as api_router
 from uedition_editor.settings import init_settings
 
+logger = logging.getLogger(__name__)
+# Configure logging
+conf = deepcopy(LOGGING_CONFIG)
+conf["loggers"]["uedition_editor"] = {
+    "level": logging.INFO,
+    "qualname": "uedition_editor",
+    "handlers": ["default"],
+}
+conf["formatters"]["default"]["fmt"] = "%(levelprefix)s %(name)-40s %(message)s"
+conf["root"] = {"level": logging.INFO}
 if init_settings.test:  # pragma: no cover
-    logging.basicConfig(level=logging.DEBUG)
+    conf["loggers"]["uedition_editor"]["level"] = logging.DEBUG
+logging.config.dictConfig(conf)
+logger.debug("Logging configuration set up")
 
 app = FastAPI()
 app.include_router(api_router)

uedition_editor/api/branches.py

@@ -9,7 +9,7 @@ from typing import Annotated
 from fastapi import APIRouter, Depends, Header
 from fastapi.exceptions import HTTPException
 from pydantic import BaseModel, Field
-from pygit2 import GitError, Repository
+from pygit2 import GitError, Repository, Signature
 from pygit2.enums import FetchPrune, RepositoryOpenFlag
 
 from uedition_editor.api.auth import get_current_user
@@ -18,6 +18,7 @@ from uedition_editor.api.files import router as files_router
 from uedition_editor.api.util import (
     BranchContextManager,
     RemoteRepositoryCallbacks,
+    commit_and_push,
     fetch_and_pull_branch,
     fetch_repo,
     pull_branch,
@@ -37,6 +38,7 @@ class BranchModel(BaseModel):
     id: str
     title: str
     nogit: bool = False
+    update_from_default: bool = False
 
 
 def slugify(slug: str) -> str:
@@ -63,7 +65,17 @@ async def branches(
             branches = []
             if category == "local":
                 for branch_name in repo.branches.local:
-                    branches.append({"id": branch_name, "title": de_slugify(branch_name)})
+                    repo.checkout(repo.branches[branch_name])
+                    diff = repo.diff(
+                        repo.revparse_single(init_settings.git.default_branch),
+                    )
+                    branches.append(
+                        {
+                            "id": branch_name,
+                            "title": de_slugify(branch_name),
+                            "update_from_default": diff.stats.files_changed > 0,
+                        }
+                    )
             elif category == "remote":
                 if init_settings.git.remote_name in list(repo.remotes.names()):
                     repo.remotes[init_settings.git.remote_name].fetch(
@@ -158,6 +170,32 @@ async def fetch_branches(
             raise HTTPException(500, "Git error") from ge
 
 
+@router.post("/{branch_id}/merge-from-default", status_code=204)
+async def merge_from_default(
+    branch_id: str,
+    current_user: Annotated[dict, Depends(get_current_user)],
+) -> None:
+    """Merge all changes from the default branch."""
+    async with BranchContextManager(branch_id) as repo:
+        repo.checkout(repo.branches[init_settings.git.default_branch])
+        if init_settings.git.remote_name in list(repo.remotes.names()):
+            fetch_repo(repo, init_settings.git.remote_name)
+            pull_branch(repo, init_settings.git.default_branch)
+        repo.checkout(repo.branches[branch_id])
+        default_branch_head = repo.revparse_single(init_settings.git.default_branch)
+        diff = repo.diff(default_branch_head)
+        if diff.stats.files_changed > 0:
+            repo.merge(default_branch_head.id)
+            commit_and_push(
+                repo,
+                init_settings.git.remote_name,
+                branch_id,
+                f"Merged {init_settings.git.default_branch}",
+                Signature(current_user["name"], current_user["sub"]),
+                extra_parents=[default_branch_head.id],
+            )
+
+
 @router.delete("/{branch_id}", status_code=204)
 async def delete_branch(
     branch_id: str,

uedition_editor/api/configs.py

@@ -13,7 +13,8 @@ from fastapi.responses import Response
 from uedition_editor.api.auth import get_current_user
 from uedition_editor.api.util import BranchContextManager, BranchNotFoundError
 from uedition_editor.settings import (
-    UEditonSettings,
+    TEINode,
+    UEditionSettings,
     UEditorSettings,
     get_uedition_settings,
     get_ueditor_settings,
@@ -23,7 +24,7 @@ from uedition_editor.settings import (
 router = APIRouter(prefix="/configs")
 
 
-@router.get("/uedition", response_model=UEditonSettings)
+@router.get("/uedition", response_model=UEditionSettings)
 async def uedition_config(
     branch_id: str,
     current_user: Annotated[dict, Depends(get_current_user)],  # noqa:ARG001
@@ -31,7 +32,17 @@ async def uedition_config(
     """Fetch the uEdition configuration."""
     try:
         async with BranchContextManager(branch_id):
-            return get_uedition_settings().model_dump()
+            settings = get_uedition_settings()
+            if "tei" in settings.sphinx_config:
+                if "blocks" in settings.sphinx_config["tei"]:
+                    settings.sphinx_config["tei"]["blocks"] = [
+                        TEINode(**block).model_dump() for block in settings.sphinx_config["tei"]["blocks"]
+                    ]
+                if "marks" in settings.sphinx_config["tei"]:
+                    settings.sphinx_config["tei"]["marks"] = [
+                        TEINode(**mark).model_dump() for mark in settings.sphinx_config["tei"]["marks"]
+                    ]
+            return settings.model_dump()
     except BranchNotFoundError as bnfe:
         raise HTTPException(404) from bnfe
 

uedition_editor/api/files.py

@@ -12,19 +12,26 @@ import shutil
 from typing import Annotated
 
 import pygit2
-from fastapi import APIRouter, Depends, Header, UploadFile
+from fastapi import APIRouter, Depends, Header, Response, UploadFile
 from fastapi.exceptions import HTTPException
 from fastapi.responses import FileResponse
 from lxml import etree
 
 from uedition_editor.api.auth import get_current_user
-from uedition_editor.api.util import BranchContextManager, BranchNotFoundError, commit_and_push
+from uedition_editor.api.util import (
+    BranchContextManager,
+    BranchNotFoundError,
+    commit_and_push,
+)
 from uedition_editor.settings import (
     TEIMetadataSection,
+    TEINode,
     TEINodeAttribute,
     TEISettings,
     TEITextSection,
+    UEditionSettings,
     UEditorSettings,
+    get_uedition_settings,
     get_ueditor_settings,
     init_settings,
 )
@@ -60,21 +67,25 @@ def guess_type(url: str) -> tuple[str | None, str | None]:
         return ("application/unknown", None)
 
 
-def build_file_tree(path: str, strip_len) -> list[dict]:
+def build_file_tree(path: str, strip_len: int, uedition_settings: UEditionSettings) -> list[dict]:
     """Recursively build a tree of directories and files."""
     files = []
     for filename in os.listdir(path):
         full_filename = os.path.join(path, filename)
         if os.path.isdir(full_filename):
-            files.append(
-                {
-                    "name": filename,
-                    "fullpath": full_filename[strip_len:],
-                    "type": "folder",
-                    "content": build_file_tree(full_filename, strip_len),
-                    "mimetype": "application/folder",
-                }
-            )
+            if filename != ".git" and full_filename[strip_len:] not in (
+                uedition_settings.output.path,
+                "_build",
+            ):
+                files.append(
+                    {
+                        "name": filename,
+                        "fullpath": full_filename[strip_len:],
+                        "type": "folder",
+                        "content": build_file_tree(full_filename, strip_len, uedition_settings),
+                        "mimetype": "application/folder",
+                    }
+                )
         elif os.path.isfile(full_filename):
             mimetype = guess_type(filename)
             files.append(
@@ -104,7 +115,7 @@ async def get_files(
                     "fullpath": "",
                     "type": "folder",
                     "mimetype": "application/folder",
-                    "content": build_file_tree(full_path, len(full_path) + 1),
+                    "content": build_file_tree(full_path, len(full_path) + 1, get_uedition_settings()),
                 }
             ]
     except BranchNotFoundError as bnfe:
@@ -220,91 +231,142 @@ def clean_tei_subdoc(node: dict) -> dict:
 
 def parse_tei_file(path: str, settings: UEditorSettings) -> list[dict]:
     """Parse a TEI file into its constituent parts."""
-    doc = etree.parse(path)  # noqa: S320
-    result = []
-    for section in settings.tei.sections:
-        section_root = doc.xpath(section.selector, namespaces=namespaces)
-        if len(section_root) == 0:
-            if section.type == "metadata":
-                result.append(
-                    {
-                        "name": section.name,
-                        "title": section.title,
-                        "type": section.type,
-                        "content": [],
-                    }
-                )
-            elif section.type == "text":
-                result.append(
-                    {
-                        "name": section.name,
-                        "title": section.title,
-                        "type": section.type,
-                        "content": {},
-                    }
-                )
-            elif section.type == "textlist":
-                result.append(
-                    {
-                        "name": section.name,
-                        "title": section.title,
-                        "type": section.type,
-                        "content": [],
-                    }
-                )
-        else:  # noqa: PLR5501
-            if section.type == "metadata":
-                result.append(
-                    {
-                        "name": section.name,
-                        "title": section.title,
-                        "type": section.type,
-                        "content": [parse_metadata_node(node) for node in section_root[0]],
-                    }
-                )
-            elif section.type == "text":
-                result.append(
-                    {
-                        "name": section.name,
-                        "title": section.title,
-                        "type": section.type,
-                        "content": clean_tei_subdoc(parse_tei_subdoc(section_root[0], settings.tei)),
-                    }
-                )
-            elif section.type == "textlist":
-                content = []
-                for node in section_root:
-                    content.append(
+    try:
+        doc = etree.parse(path)  # noqa: S320
+        result = []
+        for section in settings.tei.sections:
+            section_root = doc.xpath(section.selector, namespaces=namespaces)
+            if len(section_root) == 0:
+                if section.type == "metadata":
+                    result.append(
                         {
-                            "attrs": {"id": node.attrib["{http://www.w3.org/XML/1998/namespace}id"]},
-                            "content": clean_tei_subdoc(parse_tei_subdoc(node, settings.tei)),
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": [],
                         }
                     )
-                result.append(
-                    {
-                        "name": section.name,
-                        "title": section.title,
-                        "type": section.type,
-                        "content": content,
-                    }
-                )
-    return result
+                elif section.type == "text":
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": {},
+                        }
+                    )
+                elif section.type == "textlist":
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": [],
+                        }
+                    )
+            else:  # noqa: PLR5501
+                if section.type == "metadata":
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": [parse_metadata_node(node) for node in section_root[0]],
+                        }
+                    )
+                elif section.type == "text":
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": clean_tei_subdoc(parse_tei_subdoc(section_root[0], settings.tei)),
+                        }
+                    )
+                elif section.type == "textlist":
+                    content = []
+                    for node in section_root:
+                        content.append(
+                            {
+                                "attrs": {"id": node.attrib["{http://www.w3.org/XML/1998/namespace}id"]},
+                                "content": clean_tei_subdoc(parse_tei_subdoc(node, settings.tei)),
+                            }
+                        )
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": content,
+                        }
+                    )
+        return result
+    except etree.XMLSyntaxError as e:
+        is_empty = False
+        with open(path) as in_f:
+            if in_f.read() == "":
+                is_empty = True
+        if is_empty:
+            result = []
+            for section in settings.tei.sections:
+                if section.type == "metadata":
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": [],
+                        }
+                    )
+                elif section.type == "text":
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": {},
+                        }
+                    )
+                elif section.type == "textlist":
+                    result.append(
+                        {
+                            "name": section.name,
+                            "title": section.title,
+                            "type": section.type,
+                            "content": [],
+                        }
+                    )
+            return result
+        else:
+            raise e
 
 
 @router.get("/{path:path}", response_model=None)
 async def get_file(
     branch_id: str,
     path: str,
-    settings: Annotated[UEditorSettings, Depends(get_ueditor_settings)],
     current_user: Annotated[dict, Depends(get_current_user)],  # noqa:ARG001
+    response: Response,
 ) -> dict | FileResponse:
     """Fetch a single file from the repo."""
     try:
         async with BranchContextManager(branch_id):
+            ueditor_settings = get_ueditor_settings()
+            uedition_settings = get_uedition_settings()
             full_path = os.path.abspath(os.path.join(init_settings.base_path, *path.split("/")))
             if full_path.startswith(os.path.abspath(init_settings.base_path)) and os.path.isfile(full_path):
                 if full_path.endswith(".tei"):
-                    return parse_tei_file(full_path, settings)
+                    if "tei" in uedition_settings.sphinx_config:
+                        if "blocks" in uedition_settings.sphinx_config["tei"]:
+                            ueditor_settings.tei.blocks.extend(
+                                [TEINode(**block) for block in uedition_settings.sphinx_config["tei"]["blocks"]]
+                            )
+                        if "marks" in uedition_settings.sphinx_config["tei"]:
+                            ueditor_settings.tei.marks.extend(
+                                [TEINode(**mark) for mark in uedition_settings.sphinx_config["tei"]["marks"]]
+                            )
+                    response.headers["Content-Type"] = "application/json+tei"
+                    return parse_tei_file(full_path, ueditor_settings)
                 else:
                     return FileResponse(full_path, media_type=guess_type(full_path)[0])
             raise HTTPException(404)
@@ -585,8 +647,9 @@ def serialise_tei_text(root: dict, data: dict, settings: TEITextSection, tei_set
         parent["children"] = []
     doc = data["content"]
     # TODO: Add docu attributes to the parent node
-    for element in doc["content"]:
-        parent["children"].append(serialise_tei_text_block(element, tei_settings))
+    if "content" in doc:
+        for element in doc["content"]:
+            parent["children"].append(serialise_tei_text_block(element, tei_settings))
 
 
 def serialise_tei_textlist(root: dict, data: dict, settings: TEITextSection, tei_settings: TEISettings) -> None:
@@ -662,11 +725,21 @@ async def update_file(
     """Update the file in the repo."""
     try:
         async with BranchContextManager(branch_id) as repo:
-            settings = get_ueditor_settings()
+            ueditor_settings = get_ueditor_settings()
             full_path = os.path.abspath(os.path.join(init_settings.base_path, *path.split("/")))
             if full_path.startswith(os.path.abspath(init_settings.base_path)) and os.path.isfile(full_path):
                 if full_path.endswith(".tei"):
-                    root = serialise_tei_file(full_path, json.load(content.file), settings)
+                    uedition_settings = get_uedition_settings()
+                    if "tei" in uedition_settings.sphinx_config:
+                        if "blocks" in uedition_settings.sphinx_config["tei"]:
+                            ueditor_settings.tei.blocks.extend(
+                                [TEINode(**block) for block in uedition_settings.sphinx_config["tei"]["blocks"]]
+                            )
+                        if "marks" in uedition_settings.sphinx_config["tei"]:
+                            ueditor_settings.tei.marks.extend(
+                                [TEINode(**mark) for mark in uedition_settings.sphinx_config["tei"]["marks"]]
+                            )
+                    root = serialise_tei_file(full_path, json.load(content.file), ueditor_settings)
                     with open(full_path, "wb") as out_f:
                         out_f.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
                         out_f.write(

uedition_editor/api/util.py

@@ -3,7 +3,14 @@
 import logging
 from asyncio import Lock
 
-from pygit2 import CredentialType, GitError, KeypairFromAgent, RemoteCallbacks, Repository, Signature
+from pygit2 import (
+    CredentialType,
+    GitError,
+    KeypairFromAgent,
+    RemoteCallbacks,
+    Repository,
+    Signature,
+)
 from pygit2.enums import FetchPrune, MergeAnalysis, RepositoryOpenFlag
 
 from uedition_editor.settings import init_settings
@@ -49,7 +56,12 @@ class BranchContextManager:
 class RemoteRepositoryCallbacks(RemoteCallbacks):
     """Callback handler for connecting to remote repositories."""
 
-    def credentials(self, url: str, username_from_url: str | None, allowed_types: CredentialType):  # noqa:ARG002
+    def credentials(
+        self,
+        url: str,  # noqa: ARG002
+        username_from_url: str | None,
+        allowed_types: CredentialType,
+    ):
         """Return the credentials for the remote connection."""
         if allowed_types & CredentialType.SSH_KEY == CredentialType.SSH_KEY:
             return KeypairFromAgent(username_from_url)
@@ -64,13 +76,16 @@ def fetch_repo(repo: Repository, remote: str) -> None:
 
 def pull_branch(repo: Repository, branch: str) -> None:
     """Pull and update the branch from the remote repository."""
-    remote_default_head = repo.lookup_reference(repo.branches[branch].upstream_name)
-    result, _ = repo.merge_analysis(remote_default_head.target)
-    if result & MergeAnalysis.FASTFORWARD == MergeAnalysis.FASTFORWARD:
-        repo.checkout_tree(repo.get(remote_default_head.target))
-        local_default_head = repo.lookup_reference(f"refs/heads/{branch}")
-        local_default_head.set_target(remote_default_head.target)
-        repo.head.set_target(remote_default_head.target)
+    try:
+        remote_default_head = repo.lookup_reference(repo.branches[branch].upstream_name)
+        result, _ = repo.merge_analysis(remote_default_head.target)
+        if result & MergeAnalysis.FASTFORWARD == MergeAnalysis.FASTFORWARD:
+            repo.checkout_tree(repo.get(remote_default_head.target))
+            local_default_head = repo.lookup_reference(f"refs/heads/{branch}")
+            local_default_head.set_target(remote_default_head.target)
+            repo.head.set_target(remote_default_head.target)
+    except KeyError as e:
+        logger.error(e)
 
 
 def fetch_and_pull_branch(repo: Repository, remote: str, branch: str) -> None:
@@ -80,12 +95,21 @@ def fetch_and_pull_branch(repo: Repository, remote: str, branch: str) -> None:
     pull_branch(repo, branch)
 
 
-def commit_and_push(repo: Repository, remote: str, branch: str, commit_msg: str, author: Signature) -> None:
+def commit_and_push(
+    repo: Repository,
+    remote: str,
+    branch: str,
+    commit_msg: str,
+    author: Signature,
+    extra_parents: list[str] | None = None,
+) -> None:
     """Commit changes to the repository and push."""
     if len(repo.status()) > 0:
         logger.debug(f"Committing changes to {', '.join(repo.status().keys())}")
         ref = repo.head.name
         parents = [repo.head.target]
+        if extra_parents is not None:
+            parents.extend(extra_parents)
         index = repo.index
         index.add_all()
         index.write()

uedition_editor/cron.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2024-present Mark Hall <mark.hall@work.room3b.eu>
+#
+# SPDX-License-Identifier: MIT
+"""Regular jobs run in the background of the uEditor."""
+
+import logging
+
+import aiocron
+from pygit2 import GitError, Repository
+from pygit2.enums import RepositoryOpenFlag
+
+from uedition_editor.api.util import fetch_repo, pull_branch, uedition_lock
+from uedition_editor.settings import init_settings
+
+logger = logging.getLogger(__name__)
+
+
+@aiocron.crontab("* * * * *")
+async def sync_remote() -> None:
+    """Synchronise with the remote."""
+    async with uedition_lock:
+        try:
+            repo = Repository(init_settings.base_path, flags=RepositoryOpenFlag.NO_SEARCH)
+            repo.checkout(repo.branches[init_settings.git.default_branch])
+            if init_settings.git.remote_name in list(repo.remotes.names()):
+                logging.debug("Synchronising with remote")
+                fetch_repo(repo, init_settings.git.remote_name)
+                for branch_id in repo.branches.local:
+                    if repo.branches[branch_id].upstream is not None:
+                        pull_branch(repo, branch_id)
+        except GitError as ge:
+            logger.error(ge)