ssb-pubmd 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

ssb_pubmd/__init__.py

@@ -0,0 +1,4 @@
+from ssb_pubmd.notebook_client import configure_factbox as Factbox
+from ssb_pubmd.notebook_client import create_highchart as Highchart
+
+__all__ = ["Factbox", "Highchart"]

ssb_pubmd/__main__.py

@@ -1,23 +1,12 @@
 import sys
 
-from ssb_pubmd.adapters.cli import CliAdapter
-from ssb_pubmd.adapters.cms_client import MimirCmsClient
-from ssb_pubmd.adapters.local_storage import LocalStorageAdapter
-from ssb_pubmd.adapters.secret_manager_client import GoogleSecretManagerClient
+from ssb_pubmd.cli import run_cli
 from ssb_pubmd.config import get_config
-from ssb_pubmd.enonic_cms_manager import EnonicCmsManager
 
 
 def main() -> None:
     config = get_config()
-    cms_manager = EnonicCmsManager(
-        config=config,
-        cms_client=MimirCmsClient(config.cms_base_url),
-        secret_manager_client=GoogleSecretManagerClient(config.gc_secret_resource_name),
-        content_file_handler=LocalStorageAdapter(config.metadata_file_path),
-    )
-    cli_adapter = CliAdapter(cms_manager=cms_manager)
-    cli_adapter.run(sys.argv)
+    run_cli(sys.argv, config)
 
 
 if __name__ == "__main__":

ssb_pubmd/adapters/content_parser.py

@@ -0,0 +1,185 @@
+from collections.abc import Mapping
+from dataclasses import asdict
+from dataclasses import dataclass
+from typing import Any
+from typing import Literal
+from typing import Protocol
+
+import nh3
+
+
+@dataclass
+class Content:
+    title: str
+    content_type: str
+    publish_folder: str | None = None
+    publish_id: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    def serialize(self) -> dict[str, Any]:
+        raise NotImplementedError()
+
+class ContentParser(Protocol):
+    def parse(self, metadata: Mapping[str, Any], html: str | None) -> Content: ...
+
+
+@dataclass
+class MimirContent(Content):
+    def is_publishable(self) -> bool:
+        if self.title == "":
+            return False
+        if self.publish_id is None and self.publish_folder is None:
+            return False
+        return True
+
+    def serialize(self) -> dict[str, Any]:
+        if not self.is_publishable():
+            raise Exception()
+        s: dict[str, Any] = {
+            "contentType": "mimir:" + self.content_type,
+            "displayName": self.title,
+            "parentPath": self.publish_folder,
+            "data": {},
+        }
+        if self.publish_id is not None:
+            s["_id"] = self.publish_id
+        return s
+    
+
+@dataclass
+class Author:
+    name: str
+    email: str
+
+@dataclass
+class Article(MimirContent):
+    content_type: str = "article"
+    authors: list[Author] | None = None
+    ingress: str = ""
+    html_text: str = ""
+
+    def serialize(self) -> dict[str, Any]:
+        s = super().serialize()
+        if self.authors:
+            s["data"]["authorItemSet"] = [asdict(author) for author in self.authors]
+        s["data"]["ingress"] = self.ingress
+        s["data"]["articleText"] = self.html_text
+        return s
+
+
+GraphType = Literal["line", "pie", "column", "bar", "area", "barNegative"]
+
+
+@dataclass
+class Highchart(MimirContent):
+    content_type: str = "highchart"
+    graph_type: GraphType = "line"
+    html_table: str | None = None
+    tbml: str | None = None
+    xlabel: str = "x"
+    ylabel: str = "y"
+
+    def serialize(self) -> dict[str, Any]:
+        s = super().serialize()
+
+        if self.html_table is not None:
+            s["data"]["htmlTable"] = self.html_table
+        elif self.tbml is not None:
+            s["data"]["dataSource"] = {
+                "_selected": "tbprocessor",
+                "tbprocessor": {"urlOrId": self.tbml},
+            }
+
+        s["data"]["xAxisTitle"] = self.xlabel
+        s["data"]["yAxisTitle"] = self.ylabel
+
+        return s
+
+
+@dataclass
+class FactBox(MimirContent):
+    content_type: str = "factBox"
+    display_type: Literal["default", "sneakPeek", "aiIcon"] = "default"
+    html_text: str = ""
+
+    def serialize(self) -> dict[str, Any]:
+        s = super().serialize()
+        s["data"]["expansionBoxType"] = self.display_type
+        s["data"]["text"] = self.html_text
+        return s
+
+
+BASIC_HTML_TAGS = {
+    "p",
+    "br",
+    "strong",
+    "em",
+    "b",
+    "i",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "a",
+}
+
+
+class MimirContentParser:
+    def parse(self, metadata: Mapping[str, Any], html: str | None) -> Content:
+        match metadata.get("content_type"):
+            case "article":
+                return self._parse_article(metadata, html)
+            case "factBox":
+                return self._parse_factbox(metadata, html)
+            case "highchart":
+                return self._parse_highchart(metadata, html)
+            case _:
+                return MimirContent(**metadata)
+
+    def serialize(self, content: Content) -> dict[str, Any]:
+        if isinstance(content, MimirContent):
+            return content.serialize()
+        else:
+            raise Exception()
+
+    @classmethod
+    def _parse_article(cls, metadata: Mapping[str, Any], html: str | None) -> Article:
+        article = Article(
+            title=metadata["title"],
+            publish_folder="/ssb" + metadata["path"],
+            publish_id=metadata.get("publish_id"),
+            authors=[Author(**data) for data in metadata.get("authors", [])],
+            ingress=metadata.get("ingress", ""),
+        )
+        if html is not None:
+            allowed_html_tags = BASIC_HTML_TAGS
+            html_text = nh3.clean(html, tags=allowed_html_tags)
+            article.html_text = html_text
+        return article
+
+    @classmethod
+    def _parse_factbox(cls, metadata: Mapping[str, Any], html: str | None) -> FactBox:
+        factbox = FactBox(**metadata)
+        if html is not None:
+            allowed_html_tags = BASIC_HTML_TAGS - {"h2"}
+            html_text = nh3.clean(html, tags=allowed_html_tags)
+            factbox.html_text = html_text
+        return factbox
+
+    @classmethod
+    def _parse_highchart(
+        cls, metadata: Mapping[str, Any], html: str | None
+    ) -> Highchart:
+        highchart = Highchart(**metadata)
+        if html is not None:
+            allowed_html_tags = {"table", "tbody", "tr", "td"}
+            html_table = nh3.clean(html, tags=allowed_html_tags)
+            highchart.html_table = html_table
+        return highchart

ssb_pubmd/adapters/document_processor.py

@@ -0,0 +1,149 @@
+
+import json
+import subprocess
+from collections.abc import Iterator
+from typing import Any
+from typing import NamedTuple
+from typing import Protocol
+from typing import TypedDict
+
+import pandocfilters as pf  # type: ignore
+
+
+class Element(NamedTuple):
+    id: str
+    inner_html: str | None
+
+
+class DocumentProcessor(Protocol):
+    def load(self, raw_content: str) -> None: ...
+    def extract_metadata(self, target_key: str) -> dict[str, Any]: ...
+    def extract_elements(self, target_class: str) -> Iterator[Element]: ...
+    def replace_element(self, id_: str, new_html: str) -> None: ...
+    def extract_html(self) -> str: ...
+
+
+
+class PandocElement(TypedDict):
+    t: str
+    c: Any
+
+
+PandocDocument = TypedDict(
+    "PandocDocument",
+    {
+        "pandoc-api-version": list[int],
+        "meta": dict[str, Any],
+        "blocks": list[PandocElement],
+    },
+)
+
+
+class PandocDocumentProcessor:
+    """
+    Processor for a pandoc document, i.e. the JSON-serialized pandoc AST of a document.
+
+    Example pandoc AST with exactly one div:
+
+    ```json
+    {
+        "pandoc-api-version": [1, 23, 1],
+        "meta": {},
+        "blocks": [
+        {
+            "t": "Div",
+            "c": [
+            ["my-highchart", ["ssb"], [["title", "My highchart"]]],
+            []
+            ]
+        }
+        ]
+    }
+    ```
+    Html equivalent:
+    ```html
+    <div id="my-highchart" class="ssb" title="My highchart">
+    </div>
+    ```
+    References:
+    - Studying the result of command `pandoc FILE -t json`, where FILE is a minimal example document (e.g. Markdown or html).
+    - https://github.com/jgm/pandocfilters has some examples of how to work with the format.
+    - Note: no formal specification exists.
+    """
+
+    document: PandocDocument
+    _element_index: dict[str, int]
+
+    def load(self, raw_content: str) -> None:
+        self.document: PandocDocument = json.loads(raw_content)
+        self._element_index = {}
+
+    def extract_metadata(self, target_key: str) -> dict[str, Any]:
+        def meta_to_dict(meta: Any) -> Any:
+            t, c = meta.get("t"), meta.get("c")
+            if t == "MetaMap":
+                return {k: meta_to_dict(v) for k, v in c.items()}
+            elif t == "MetaList":
+                return [meta_to_dict(v) for v in c]
+            else:
+                return pf.stringify(c)
+
+        return meta_to_dict(self.document["meta"][target_key])  # type: ignore
+
+    def extract_html(self) -> str:
+        return self._document_to_html(self.document)
+
+    def extract_elements(self, target_class: str) -> Iterator[Element]:
+        self._element_index = self._generate_element_index(target_class)
+
+        for id_, i in self._element_index.items():
+            element = self.document["blocks"][i]
+            inner_blocks: list[PandocElement] = element["c"][1]
+            inner_html = self._blocks_to_html(inner_blocks) if inner_blocks else None
+            yield Element(id_, inner_html)
+
+    def replace_element(self, id_: str, new_html: str) -> None:
+        i = self._element_index[id_]
+        self.document["blocks"][i] = {
+            "t": "RawBlock",
+            "c": ["html", new_html],
+        }
+
+    def _generate_element_index(self, target_class: str) -> dict[str, int]:
+        index = {}
+        for i, element in enumerate(self.document["blocks"]):
+            if element["t"] != "Div":
+                continue
+
+            id_: str = element["c"][0][0]
+            if not id_:
+                continue
+
+            classes: list[str] = element["c"][0][1]
+            if target_class not in classes:
+                continue
+
+            index[id_] = i
+
+        return index
+
+    @classmethod
+    def _blocks_to_html(cls, blocks: list[PandocElement]) -> str:
+        document: PandocDocument = {
+            "pandoc-api-version": [1, 23, 1],
+            "meta": {},
+            "blocks": blocks,
+        }
+        return cls._document_to_html(document)
+
+    @classmethod
+    def _document_to_html(cls, document: PandocDocument) -> str:
+        result = subprocess.run(
+            ["pandoc", "-f", "json", "-t", "html"],
+            input=json.dumps(document),
+            text=True,
+            capture_output=True,
+            check=True,
+        )
+        html = result.stdout
+        return html

ssb_pubmd/adapters/publish_client.py

@@ -0,0 +1,117 @@
+import os
+from dataclasses import dataclass
+from typing import Any
+from typing import NamedTuple
+from typing import Protocol
+
+import requests
+from dapla_auth_client import AuthClient
+
+from ssb_pubmd.adapters.content_parser import Content
+from ssb_pubmd.config import Config
+
+
+class PublishClientError(Exception): ...
+
+class HttpClient(Protocol):
+    def post(
+        self, url: str, headers: dict[str, str], payload: dict[str, Any]
+    ) -> dict[str, str]: ...
+
+class RequestsHttpClient:
+    def post(
+        self, url: str, headers: dict[str, str], payload: dict[str, Any]
+    ) -> dict[str, str]:
+        response = requests.post(
+            url,
+            headers=headers,
+            json=payload,
+        )
+        body = response.json()
+        if not response.ok:
+            raise PublishClientError(
+                f"Sync failed. Response message: {body.get('msg', 'no message')}"
+            )
+        return body  # type: ignore
+
+class TokenClient(Protocol):
+    def get_token(self) -> str: ...
+
+
+class LocalTokenClient:
+    def get_token(self) -> str:
+        return os.environ.get("OIDC_TOKEN", "")
+
+
+class DaplaTokenClient:
+    def get_token(self) -> str:
+        return AuthClient.fetch_personal_token(audiences=["ssbno"])
+
+class Response(NamedTuple):
+    publish_path: str
+    publish_id: str
+    publish_url: str
+    publish_html: str
+
+class PublishClient(Protocol):
+    http_client: HttpClient
+
+    def send_content(self, content: Content) -> Response: ...
+
+DEFAULT_HTTP_CLIENT = RequestsHttpClient()
+DEFULT_TOKEN_CLIENT = LocalTokenClient()
+@dataclass
+class MimirPublishClient:
+    base_url: str
+    endpoint: str
+    preview_base_path: str
+    http_client: HttpClient = DEFAULT_HTTP_CLIENT
+    token_client: TokenClient = DEFULT_TOKEN_CLIENT
+
+    def _create_headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.token_client.get_token()}",
+            "Content-Type": "application/json",
+        }
+
+    def send_content(self, content: Content) -> Response:
+        headers = self._create_headers()
+        response_body = self.http_client.post(
+            url=f"{self.base_url}{self.endpoint}",
+            headers=headers,
+            payload=content.serialize(),
+        )
+
+        id_ = response_body.get("_id")
+        path = response_body.get("_path")
+
+        if path is None or id_ is None:
+            raise PublishClientError("Sync failed. Could not parse response body.")
+
+        macro_type = (
+            content.content_type
+            if content.content_type in ["highchart", "factBox"]
+            else None
+        )
+        if id_ is not None and macro_type is not None:
+            html = f"<p>[ {macro_type} {content.content_type}=&quot;{id_}&quot; /]</p>"
+        else:
+            html = ""
+
+        return Response(
+            publish_path=path,
+            publish_id=id_,
+            publish_url=self.base_url + self.preview_base_path + path,
+            publish_html=html,
+        )
+
+
+def get_publish_client(config: Config) -> PublishClient:
+    return MimirPublishClient(
+        base_url=config.publish_base_url,
+        endpoint="/webapp/pubmd",
+        preview_base_path=config.publish_admin_path + "/site/preview/default/draft",
+        token_client=DaplaTokenClient()
+        if config.use_dapla_token_client
+        else DEFULT_TOKEN_CLIENT,
+    )

ssb_pubmd/adapters/storage.py

@@ -0,0 +1,42 @@
+import json
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+from typing import Protocol
+
+
+class Storage(Protocol):
+    def update(self, key: str, data: Mapping[str, Any]) -> None: ...
+    def get(self, key: str) -> dict[str, Any]: ...
+
+class LocalFileStorage:
+    path: Path
+
+    def __init__(self, project_folder: Path) -> None:
+        self.path = project_folder / ".ssbno.json"
+        if not self.path.exists():
+            with self.path.open("w") as f:
+                json.dump({}, f)
+
+    def _load(self) -> dict[str, dict[str, Any]]:
+        with self.path.open() as f:
+            return json.load(f)  # type: ignore
+
+    def _save(self, data: dict[str, dict[str, Any]]) -> None:
+        with self.path.open("w") as f:
+            json.dump(data, f, indent=2)
+
+    def update(self, key: str, data: Mapping[str, Any]) -> None:
+        store = self._load()
+
+        current = store.get(key, {})
+        for field, value in data.items():
+            if value is not None:
+                current[field] = value
+
+        store[key] = current
+        self._save(store)
+
+    def get(self, key: str) -> dict[str, Any]:
+        store = self._load()
+        return store.get(key, {}).copy()

ssb_pubmd/cli.py

@@ -0,0 +1,102 @@
+import subprocess
+import sys
+from importlib import resources
+from pathlib import Path
+
+from jinja2 import Template
+from watchfiles import watch
+
+from ssb_pubmd import templates
+from ssb_pubmd.adapters.content_parser import MimirContentParser
+from ssb_pubmd.adapters.document_processor import PandocDocumentProcessor
+from ssb_pubmd.adapters.publish_client import PublishClient
+from ssb_pubmd.adapters.publish_client import get_publish_client
+from ssb_pubmd.adapters.storage import LocalFileStorage
+from ssb_pubmd.config import Config
+from ssb_pubmd.domain.document_publisher import sync_document
+
+
+def run_cli(system_arguments: list[str], config: Config) -> None:
+    match system_arguments:
+        case [_, "create", filename]:
+            _create_template(filename, config)
+        case [_, "preview", filename]:
+            _preview(filename, config)
+        case _:
+            print("Usage:")
+            print("  ssb-pubmd create FILENAME")
+            print("  ssb-pubmd preview FILENAME")
+            sys.exit(1)
+
+
+def _create_template(filename: str, config: Config) -> None:
+    destination = Path.cwd() / filename
+    if destination.suffix != ".qmd":
+        print("The destination file path must have the '.qmd' extension.")
+        sys.exit(1)
+
+    with resources.open_text(templates, "template.qmd") as file:
+        raw_template = file.read()
+
+    rendered_template = Template(raw_template).render(
+        filepath=destination,
+        cms_admin_url=config.publish_base_url + config.publish_admin_path,
+        project_folder=destination.parent.name,
+        filename=destination.name,
+    )
+    destination.write_text(rendered_template)
+    print(
+        f"Successfully created template file {destination}.\n",
+        "Open the file for further instructions.",
+    )
+
+
+def _preview(file_path: str, config: Config) -> None:
+    if Path(file_path).suffix != ".qmd":
+        print("Only Quarto Markdown (.qmd) files are supported.")
+        sys.exit(1)
+
+    publish_client = get_publish_client(config)
+
+    _sync_updated_file(file_path, publish_client)
+
+    print("Watching for file changes...")
+    for changes in watch(file_path):
+        print("Found changes:")
+        print(changes)
+        _sync_updated_file(file_path, publish_client)
+
+def _sync_updated_file(file_path: str, publish_client: PublishClient) -> None:
+    print("Syncing updated document...")
+    preview_url = _sync_quarto_file(file_path, publish_client)
+    print(f"Content synced successfully. Preview URL: {preview_url}")
+
+def _sync_quarto_file(file_path: str, publish_client: PublishClient) -> str:
+    pandoc_document = _quarto_to_pandoc(file_path)
+    adapters = (
+        PandocDocumentProcessor(),
+        MimirContentParser(),
+        LocalFileStorage(project_folder=Path(file_path).parent),
+        publish_client,
+    )
+    return sync_document(pandoc_document, *adapters)
+
+
+def _quarto_to_pandoc(file_path: str) -> str:
+    result = subprocess.run(
+        [
+            "quarto",
+            "render",
+            file_path,
+            "--to",
+            "json",
+            "-M",
+            "include:false",
+            "--output",
+            "-",
+        ],
+        text=True,
+        capture_output=True,
+        check=True,
+    )
+    return result.stdout

ssb_pubmd/config.py

@@ -1,27 +1,37 @@
+"""App configuration through environment variables."""
+
 import os
 from dataclasses import dataclass
 from pathlib import Path
 
-APP_NAME = "SSB_PUBMD"
-
 
 @dataclass
 class Config:
-    metadata_file_path: Path
-    cms_base_url: str
-    gc_secret_resource_name: str
+    publish_base_url: str
+    publish_admin_path: str
+    use_dapla_token_client: bool
+
+
+_TEST_CONFIG = Config(
+    publish_base_url="https://i.test.ssb.no",
+    publish_admin_path="/xp/admin",
+    use_dapla_token_client=True,
+)
+
+_LOCAL_CONFIG = Config(
+    publish_base_url="http://localhost:8080",
+    publish_admin_path="/admin",
+    use_dapla_token_client=False,
+)
 
 
 def get_config(metadata_file_path: Path | None = None) -> Config:
-    user_data_dir = Path.home() / ".local" / "share" / APP_NAME
-    if not metadata_file_path:
-        user_data_dir.mkdir(parents=True, exist_ok=True)
-        metadata_file_path = user_data_dir / "metadata.json"
-    if not metadata_file_path.exists():
-        with open(metadata_file_path, "x") as metadata_file:
-            metadata_file.write("{}\n")
-    return Config(
-        metadata_file_path=metadata_file_path,
-        cms_base_url=os.environ[f"{APP_NAME}_BASE_URL"],
-        gc_secret_resource_name=os.environ[f"{APP_NAME}_GC_SECRET_RESOURCE_NAME"],
-    )
+    if os.environ.get("SSB_PUBMD_ENVIRONMENT") == "local":
+        config = _LOCAL_CONFIG
+    else:
+        config = _TEST_CONFIG
+
+    if os.environ.get("SSB_PUBMD_TOKEN_CLIENT") == "local":
+        config.use_dapla_token_client = False
+
+    return config