ssb-pubmd 0.1.0__py3-none-any.whl → 0.1.1__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,124 @@
+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:
+    token: str
+
+    def __init__(self) -> None:
+        self.token = AuthClient.fetch_personal_token(audiences=["ssbno"])
+
+    def get_token(self) -> str:
+        return self.token
+
+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, use_dapla_token_client: bool = False
+) -> PublishClient:
+    return MimirPublishClient(
+        base_url=config.publish_base_url,
+        endpoint=config.publish_endpoint,
+        preview_base_path=config.publish_preview_base_path,
+        token_client=DaplaTokenClient()
+        if 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,78 @@
+import subprocess
+import sys
+from pathlib import Path
+
+from watchfiles import watch
+
+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 [_, "preview", file_path]:
+            _preview(file_path, config)
+        case _:
+            print("Usage: ssb-pubmd preview QUARTO_MARKDOWN_FILE")
+            sys.exit(1)
+
+
+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)
+    try:
+        print("Fetching labid token...")
+        publish_client = get_publish_client(config, use_dapla_token_client=True)
+    except Exception:
+        print("Failed to fetch labid token; using environment variable...")
+        publish_client = get_publish_client(config, use_dapla_token_client=False)
+
+    _sync_updated_file(file_path, publish_client)
+
+    print("Watching for file changes...")
+    for changes in watch(file_path):
+        _sync_updated_file(file_path, publish_client)
+
+def _sync_updated_file(file_path: str, publish_client: PublishClient) -> None:
+    print("Syncing updated document...")
+    try:
+        preview_url = _sync_quarto_file(file_path, publish_client)
+        print(f"Content synced successfully. Preview URL: {preview_url}")
+    except Exception as e:
+        print(f"Error during sync: {e}")
+
+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,3 +1,5 @@
+"""App configuration through environment variables."""
+
 import os
 from dataclasses import dataclass
 from pathlib import Path
@@ -7,21 +9,15 @@ 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_endpoint: str
+    publish_preview_base_path: str
 
 
 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")
+    """Get config from enviromnent variables."""
     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"],
+        publish_base_url=os.environ[f"{APP_NAME}_BASE_URL"],
+        publish_endpoint=os.environ[f"{APP_NAME}_ENDPOINT"],
+        publish_preview_base_path=os.environ[f"{APP_NAME}_PREVIEW_BASE_PATH"],
     )

ssb_pubmd/domain/document_publisher.py

@@ -0,0 +1,46 @@
+from ssb_pubmd.adapters.content_parser import ContentParser
+from ssb_pubmd.adapters.document_processor import DocumentProcessor
+from ssb_pubmd.adapters.publish_client import PublishClient
+from ssb_pubmd.adapters.storage import Storage
+
+USER_KEY_PREFIX = "user:"
+DOCUMENT_KEY = "app:document"
+
+def sync_document(
+    raw_document_content: str,
+    document_processor: DocumentProcessor,
+    content_parser: ContentParser,
+    storage: Storage,
+    publish_client: PublishClient,
+) -> str:
+    document_processor.load(raw_document_content)
+
+    document_metadata = document_processor.extract_metadata(target_key="ssb")
+    document_metadata["content_type"] = "article"
+
+    document_publish_path = storage.get(DOCUMENT_KEY).get("publish_path")
+    if not document_publish_path:
+        content = content_parser.parse(metadata=document_metadata, html=None)
+        response = publish_client.send_content(content)
+        storage.update(
+            DOCUMENT_KEY,
+            {"publish_id": response.publish_id, "publish_path": response.publish_path},
+        )
+        document_publish_path = response.publish_path
+
+    document_elements = document_processor.extract_elements(target_class="ssb")
+    for id_, html in document_elements:
+        key = USER_KEY_PREFIX + id_
+        metadata = storage.get(key) | {"publish_folder": document_publish_path}
+        component = content_parser.parse(metadata, html)
+        response = publish_client.send_content(component)
+        storage.update(key, {"publish_id": response.publish_id})
+        document_processor.replace_element(id_, response.publish_html)
+
+    article_metadata = document_metadata | {
+        "publish_id": storage.get(DOCUMENT_KEY).get("publish_id")
+    }
+    html = document_processor.extract_html()
+    article = content_parser.parse(metadata=article_metadata, html=html)
+    response = publish_client.send_content(article)
+    return response.publish_url

ssb_pubmd/notebook_client.py

@@ -0,0 +1,130 @@
+from pathlib import Path
+from typing import Literal
+
+import narwhals as nw
+from narwhals.typing import IntoDataFrame
+
+from ssb_pubmd.adapters.content_parser import Content
+from ssb_pubmd.adapters.content_parser import ContentParser
+from ssb_pubmd.adapters.content_parser import MimirContentParser
+from ssb_pubmd.adapters.storage import LocalFileStorage
+from ssb_pubmd.adapters.storage import Storage
+from ssb_pubmd.domain.document_publisher import USER_KEY_PREFIX
+
+STORAGE: Storage = LocalFileStorage(project_folder=Path.cwd())
+CONTENT_PARSER: ContentParser = MimirContentParser()
+
+class NotebookClientError(Exception): ...
+
+def configure_factbox(
+    key: str,
+    title: str,
+    display_type: Literal["default", "sneakPeek", "aiIcon"] = "default",
+) -> None:
+    """Oppretter en faktaboks og printer en Markdown-snippet som kan limes inn i artikkelen (på en ny linje).
+
+    :param key: En unik nøkkel for innholdet.
+    :param title: Tittelen til faktaboksen.
+    :param display_type: Visning av faktaboksen.
+
+        Alternativer:
+
+        * "default": Bare tittel (standard)
+        * "sneakPeek": Tittel og litt av forklaringsteksten
+        * "aiIcon": Tittel og litt av forklaringsteksten + KI-ikon
+    """
+    metadata = {
+        "content_type": "factBox",
+        "title": title,
+        "display_type": display_type,
+    }
+
+    content = CONTENT_PARSER.parse(
+        metadata=metadata,
+        html=None,
+    )
+    _store_user_content(user_key=key, content=content)
+
+    md = _get_markdown_snippet(key, placeholder_text="Faktaboksens tekst skrives her.")
+    print(md)
+
+
+def create_highchart(
+    key: str,
+    title: str,
+    dataframe: IntoDataFrame | None = None,
+    tbml: str | None = None,
+    graph_type: Literal["line", "pie", "column", "bar", "area", "barNegative"] = "line",
+    xlabel: str = "x",
+    ylabel: str = "y"
+) -> None:
+    """Oppretter et highchart og printer en Markdown-snippet som kan limes inn i artikkelen (på en ny linje).
+
+    Som datakilde er det nødvendig å spesifisere enten `dataframe` eller `tbml`.
+
+    :param key: En unik nøkkel for innholdet.
+    :param title: Tittelen til highchartet.
+    :param dataframe: En pandas, Polars eller PyArrow dataframe.
+    :param tbml: URL eller TBML-id.
+    :param graph_type: Graftype.
+
+        Alternativer:
+
+        * "line": Linje (standard)
+        * "pie": Kake
+        * "column": Stolpe
+        * "bar": Liggende stolpe
+        * "area": Areal
+        * "barNegative": Pyramide
+
+    :param xlabel: X-akse, tittel.
+    :param ylabel: Y-akse, tittel.
+    """
+    if dataframe is None and tbml is None:
+        raise NotebookClientError("Either 'dataframe' or 'tbml' must be specified.")
+    metadata = {
+        "content_type": "highchart",
+        "title": title,
+        "graph_type": graph_type,
+        "xlabel": xlabel,
+        "ylabel": ylabel
+    }
+    if tbml is not None:
+        metadata["tbml"] = tbml
+    html = _dataframe_to_html_table(dataframe) if dataframe is not None else None
+    content = CONTENT_PARSER.parse(metadata, html)
+    _store_user_content(user_key=key, content=content)
+
+    md = _get_markdown_snippet(key)
+    print(md)
+
+
+def _store_user_content(user_key: str, content: Content) -> None:
+    key = USER_KEY_PREFIX + str(user_key)
+    STORAGE.update(key, content.to_dict())
+
+
+def _dataframe_to_html_table(dataframe: IntoDataFrame) -> str:
+    df = nw.from_native(dataframe)
+    html = "<table><tbody>\n"
+
+    html += "<tr>\n"
+    for name in df.columns:
+        html += f"    <td>{name}</td>\n"
+    html += "</tr>\n"
+
+    for row in df.iter_rows():
+        html += "  <tr>\n"
+        for value in row:
+            html += f"    <td>{value}</td>\n"
+        html += "  </tr>\n"
+
+    html += "</tbody></table>"
+
+    return html
+
+
+def _get_markdown_snippet(key: str, placeholder_text: str | None = None) -> str:
+    div_config = f"{{ #{key} .ssb }}"
+    div_content = f"\n{placeholder_text}\n\n" if placeholder_text is not None else ""
+    return f"::: {div_config}\n{div_content}:::"

{ssb_pubmd-0.1.0.dist-info → ssb_pubmd-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.1.0
+Version: 0.1.1
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -13,12 +13,15 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: cryptography (>=45.0.5,<46.0.0)
-Requires-Dist: google-cloud-secret-manager (>=2.24.0,<3.0.0)
+Requires-Dist: dapla-auth-client (>=1.2.5,<2.0.0)
+Requires-Dist: ipynbname (>=2025.8.0.0,<2026.0.0.0)
+Requires-Dist: narwhals (>=2.15.0,<3.0.0)
 Requires-Dist: nbformat (>=5.10.4,<6.0.0)
-Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
+Requires-Dist: nh3 (>=0.3.2,<0.4.0)
+Requires-Dist: pandocfilters (>=1.5.1,<2.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
 Requires-Dist: requests (>=2.32.4,<3.0.0)
-Requires-Dist: types-requests (>=2.32.4.20250611,<3.0.0.0)
+Requires-Dist: watchfiles (>=1.1.1,<2.0.0)
 Project-URL: Changelog, https://github.com/statisticsnorway/ssb-pubmd/releases
 Project-URL: Documentation, https://statisticsnorway.github.io/ssb-pubmd
 Project-URL: Homepage, https://github.com/statisticsnorway/ssb-pubmd

ssb_pubmd-0.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+ssb_pubmd/__init__.py,sha256=GmZebzEEIJcwwYD6_J5irpY5-lGAKFr8lRrTGB_nAPA,170
+ssb_pubmd/__main__.py,sha256=7Trn-DZkNbVn6s5J8FVg9JFtpFEHv-4VKZ34MVs23Cc,204
+ssb_pubmd/adapters/content_parser.py,sha256=ExOULfwoFBVb9h2wH8m61fWFy192ZEIG2LI3fuFRpbE,5141
+ssb_pubmd/adapters/document_processor.py,sha256=GN4FJmWcyiCdTBzWkyUReFGd7AME-F4Eq5N4JmarddQ,4271
+ssb_pubmd/adapters/publish_client.py,sha256=mBRfOEEcrmKlDHJVsaqQR984XlJel9oBK4PGP-GhriE,3451
+ssb_pubmd/adapters/storage.py,sha256=Dexfgw0csQ9wljC6lqf9kFmoM2CHdfMghm-qBrgdWjM,1227
+ssb_pubmd/cli.py,sha256=dusmoCX3U6Lpc_uSqqgCRC0U0m8fRq48ExdsYBXRtr4,2555
+ssb_pubmd/config.py,sha256=chnW-GC5Ie5kEcjVb-4_a5_Vq6glhATorDVIghc50SI,606
+ssb_pubmd/domain/document_publisher.py,sha256=hgzJx9kGZJOVLrgFRg-JGAmNsasvHA9_BA1g3htcWrQ,1920
+ssb_pubmd/notebook_client.py,sha256=MANyeyIdTuci8b0flD9e3jgFnEwx5dGo4zLMp39tkRE,4007
+ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ssb_pubmd-0.1.1.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
+ssb_pubmd-0.1.1.dist-info/METADATA,sha256=z_bEnr4p9KiPhscq4X5r8mHmn34Wambsacj7DLlp_bA,4101
+ssb_pubmd-0.1.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+ssb_pubmd-0.1.1.dist-info/entry_points.txt,sha256=o4oU99zbZNIBKGYWdgdEG6ev-62ZRWEJOe7EOjJaajk,53
+ssb_pubmd-0.1.1.dist-info/RECORD,,

ssb_pubmd/adapters/cli.py

@@ -1,21 +0,0 @@
-import sys
-from dataclasses import dataclass
-
-from ssb_pubmd.ports import CmsManager
-
-
-@dataclass
-class CliAdapter:
-    cms_manager: CmsManager
-
-    def run(self, system_arguments: list[str]) -> None:
-        match system_arguments:
-            case [_, "sync", file_path]:
-                preview = self.cms_manager.sync(file_path)
-                print(f"Preview URL: {preview}")
-                # except Exception as e:
-                #     print(f"Error during sync: {e}")
-                #     sys.exit(1)
-            case _:
-                print("Usage: ssb-pubmd sync <content_file_path>")
-                sys.exit(1)

ssb_pubmd/adapters/cms_client.py

@@ -1,47 +0,0 @@
-from urllib.parse import urlparse
-
-import requests
-
-from ssb_pubmd.models import CmsResponse
-from ssb_pubmd.models import Content
-
-
-class CmsClientError(Exception): ...
-
-
-class MimirCmsClient:
-    base_url: str
-
-    def __init__(self, base_url: str) -> None:
-        self.base_url = base_url
-
-    def _convert_preview_url(self, url_from_response: str) -> str:
-        """Convert the preview URL to a full URL if it's relative."""
-        url = urlparse(url_from_response)
-        if url.scheme and url.netloc:
-            return url.geturl()
-        else:
-            return urlparse(self.base_url)._replace(path=url.path).geturl()
-
-    def send(self, token: str, content: Content) -> CmsResponse:
-        """Sends a request to the Enonic CMS, assumed to have the mimir application installed (currently this only works with the feature branch https://github.com/statisticsnorway/mimir/pull/3192)."""
-        try:
-            response = requests.post(
-                f"{self.base_url}/_/service/mimir/postMarkdown",
-                headers={
-                    "Authorization": f"Bearer {token}",
-                    "Content-Type": "application/json",
-                },
-                json=content.to_json(),
-            )
-            if response.status_code != 200:
-                raise CmsClientError(
-                    f"Request to CMS failed with status code {response.status_code}."
-                )
-            body = response.json()
-            return CmsResponse(
-                id=body["_id"],
-                preview_url=self._convert_preview_url(body["previewPath"]),
-            )
-        except Exception as e:
-            raise CmsClientError("Request to CMS failed.") from e

ssb_pubmd/adapters/local_storage.py

@@ -1,72 +0,0 @@
-import json
-from dataclasses import dataclass
-from pathlib import Path
-
-import nbformat
-
-from ssb_pubmd.models import Content
-
-ID_KEY = "_id"
-
-
-class LocalStorageError(Exception): ...
-
-
-@dataclass
-class LocalStorageAdapter:
-    metadata_file_path: Path
-
-    def get_file_id(self, file_path: Path) -> str:
-        """
-        Returns the content id of a given file path.
-        If no id is registered for the given file path,
-        it returns an empty string.
-        """
-        with open(self.metadata_file_path) as metadata_file:
-            metadata = json.load(metadata_file)
-            return str(metadata.get(str(file_path.absolute()), {}).get(ID_KEY, ""))
-
-    def set_file_id(self, file_path: Path, content_id: str) -> None:
-        """Stores a given file's content id in the metadata file"""
-        with open(self.metadata_file_path) as metadata_file:
-            metadata = json.load(metadata_file)
-        metadata[str(file_path.absolute())] = {ID_KEY: content_id}
-        with open(self.metadata_file_path, "w") as metadata_file:
-            json.dump(metadata, metadata_file)
-
-    def get_content(self, file_path: Path) -> Content:
-        """
-        Returns the markdown content of a given file.
-        If the file is neither a .md or a .ipynb file,
-        this function will throw a `LocalStorageError`
-        """
-        return Content(
-            content_id=self.get_file_id(file_path),
-            file_path=file_path,
-            markdown=self._get_content(file_path),
-        )
-
-    def _get_content_from_notebook_file(self, file_path: Path) -> str:
-        """Extracts all markdown cells from the notebook and returns it as a string."""
-        notebook = nbformat.read(file_path, as_version=nbformat.NO_CONVERT)  # type: ignore
-        markdown_cells = []
-        for cell in notebook.cells:
-            if cell.cell_type == "markdown":
-                markdown_cells.append(cell.source)
-        sep = "\n\n"
-        return sep.join(markdown_cells)
-
-    def _get_content_from_markdown_file(self, file_path: Path) -> str:
-        """Returns the content of a markdown file as a string."""
-        with open(file_path) as file:
-            return file.read()
-
-    def _get_content(self, file_path: Path) -> str:
-        file_type = file_path.suffix
-        match file_type:
-            case ".md":
-                return self._get_content_from_markdown_file(file_path)
-            case ".ipynb":
-                return self._get_content_from_notebook_file(file_path)
-            case _:
-                raise LocalStorageError(f"Unsupported file type: {file_type}")

ssb_pubmd/adapters/secret_manager_client.py

@@ -1,66 +0,0 @@
-"""This module handles HTTP requests and responses to and from the CMS."""
-
-import json
-from dataclasses import dataclass
-from datetime import datetime
-
-import jwt
-from google.cloud import secretmanager
-
-
-@dataclass
-class Secret:
-    private_key: str
-    kid: str
-    principal_key: str
-
-
-class SecretManagerError(Exception): ...
-
-
-class GoogleSecretManagerClient:
-    TYPE = "JWT"
-    ALGORITHM = "RS256"
-    _gc_secret_resource_name: str
-
-    def __init__(self, gc_secret_resource_name: str) -> None:
-        self._gc_secret_resource_name = gc_secret_resource_name
-
-    def _get_secret(self) -> Secret:
-        """Fetches the private key and related data from Google Cloud Secret Manager."""
-        client = secretmanager.SecretManagerServiceClient()
-        response = client.access_secret_version(name=self._gc_secret_resource_name)
-        raw_data = response.payload.data.decode("UTF-8")
-        data = json.loads(raw_data)
-        try:
-            return Secret(
-                private_key=data["privateKey"],
-                kid=data["kid"],
-                principal_key=data["principalKey"],
-            )
-        except KeyError as e:
-            raise SecretManagerError(
-                "The secret must be a JSON object with keys 'privateKey', 'kid' and 'principalKey'."
-            ) from e
-
-    def generate_token(self) -> str:
-        secret = self._get_secret()
-
-        header = {
-            "kid": secret.kid,
-            "typ": self.TYPE,
-            "alg": self.ALGORITHM,
-        }
-
-        iat = int(datetime.now().timestamp())
-        exp = iat + 30
-        payload = {
-            "sub": secret.principal_key,
-            "iat": iat,
-            "exp": exp,
-        }
-
-        token = jwt.encode(
-            payload, secret.private_key, algorithm=self.ALGORITHM, headers=header
-        )
-        return token

ssb_pubmd/enonic_cms_manager.py

@@ -1,30 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-from ssb_pubmd.config import Config
-from ssb_pubmd.ports import CmsClient
-from ssb_pubmd.ports import ContentFileHandler
-from ssb_pubmd.ports import SecretManagerClient
-
-
-@dataclass
-class EnonicCmsManager:
-    """A CMS Mananager tailored to the Enonic CMS."""
-
-    config: Config
-    cms_client: CmsClient
-    secret_manager_client: SecretManagerClient
-    content_file_handler: ContentFileHandler
-
-    def sync(self, content_file_path: str) -> str:
-        """Requests that Enonic stores/updates the given contant file and gives back a rendered preview.
-
-        The details of the communication are handled by the CmsClient implementation, which in turn depends on the services that are exposed by the Enonic XP application. The only thing this class cares is that it receives a CmsResponse object, which contains an id and preview url of the content.
-        """
-        content = self.content_file_handler.get_content(Path(content_file_path))
-        response = self.cms_client.send(
-            token=self.secret_manager_client.generate_token(),
-            content=content,
-        )
-        self.content_file_handler.set_file_id(content.file_path, response.id)
-        return response.preview_url

ssb_pubmd/models.py

@@ -1,28 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass
-class CmsResponse:
-    id: str
-    preview_url: str
-
-
-@dataclass
-class Content:
-    content_id: str
-    file_path: Path
-    markdown: str
-
-    @property
-    def display_name(self) -> str:
-        """Generate a display name for the content."""
-        return self.file_path.stem.replace("_", " ").title()
-
-    def to_json(self) -> dict[str, str]:
-        """Returns a json representation of the content."""
-        return {
-            "_id": self.content_id,
-            "displayName": self.display_name,
-            "markdown": self.markdown,
-        }

ssb_pubmd/ports.py

@@ -1,57 +0,0 @@
-from pathlib import Path
-from typing import Protocol
-
-from ssb_pubmd.models import CmsResponse
-from ssb_pubmd.models import Content
-
-
-class CmsManager(Protocol):
-    """An interface (primary port) for managing a CMS.
-
-    An implementing class is tailored to a specific CMS application.
-    """
-
-    def sync(self, content_file_path: str) -> str:
-        """Requests that the CMS stores and renders the given content file.
-
-        :param content_file_path: The path to the content file to be rendered.
-        :return: A URL to the rendered preview.
-        """
-        ...
-
-
-class CmsClient(Protocol):
-    """An interface (secondary port) for communicating with a CMS.
-
-    An implementing class is tailored to a specific CMS, with its specific exposed services and token authentication flow.
-    """
-
-    def send(self, token: str, content: Content) -> CmsResponse: ...
-
-
-class ContentFileHandler(Protocol):
-    """An interface (secondary port) for handling content files, including extraction and handling of metadata."""
-
-    def get_file_id(self, file_path: Path) -> str:
-        """
-        Returns the id of a given file path.
-        If no id is registered for the given file path,
-        it returns an empty string.
-        """
-        ...
-
-    def set_file_id(self, file_path: Path, content_id: str) -> None:
-        """Sets the id of a given file path."""
-        ...
-
-    def get_content(self, file_path: Path) -> Content:
-        """
-        Extracts the content of a given file.
-        """
-        ...
-
-
-class SecretManagerClient(Protocol):
-    """An interface (secondary port) for communicating with a secret manager and generating tokens."""
-
-    def generate_token(self) -> str: ...

ssb_pubmd-0.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-ssb_pubmd/__main__.py,sha256=rjxFBSqNHykkGrEfY6t9e1gZfv2vksjsT3YJSjOvNlc,816
-ssb_pubmd/adapters/cli.py,sha256=DO5HVGUH2FEZDoLpJs-kUCln1D6uapHVXQfeaIoQHGg,627
-ssb_pubmd/adapters/cms_client.py,sha256=vPA2xhffb4ubDr9_9qMN4MuNp2gg2SLjOVoZAnWgo2o,1699
-ssb_pubmd/adapters/local_storage.py,sha256=3LPWRlmQSdlDhmU23yBD33x13HWKjYuvKfg2i8Ghh0A,2595
-ssb_pubmd/adapters/secret_manager_client.py,sha256=fmFUiWzt9Ajvn5dYswFdh23JV7_zkDM15tunSfaHCXM,1839
-ssb_pubmd/config.py,sha256=ZSynxkTY4s-qUKG6DO_Ss_txGjtB20um46hV1pbEndw,838
-ssb_pubmd/enonic_cms_manager.py,sha256=lNYTkydPXkYvXhVQZcOqzy4J8iKQTPVEgTS72ZnqcW0,1264
-ssb_pubmd/models.py,sha256=Lbi5qaEbJhOl3Cp9Fx2-ie74o3J4ptodLasPyuBGyFM,626
-ssb_pubmd/ports.py,sha256=sTZ06jVrUy_fk0G3yeduo13nmXa9ZiXyts_UVBNUFow,1703
-ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ssb_pubmd-0.1.0.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
-ssb_pubmd-0.1.0.dist-info/METADATA,sha256=YYgpiyNdhQCXAZFa1TUbPuqCpRRTL7XSbYYSWbmyvfA,3996
-ssb_pubmd-0.1.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-ssb_pubmd-0.1.0.dist-info/entry_points.txt,sha256=o4oU99zbZNIBKGYWdgdEG6ev-62ZRWEJOe7EOjJaajk,53
-ssb_pubmd-0.1.0.dist-info/RECORD,,