ssb-pubmd 0.1.0__tar.gz → 0.1.2__tar.gz

{ssb_pubmd-0.1.0 → ssb_pubmd-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.1.0
+Version: 0.1.2
 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.0 → ssb_pubmd-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-pubmd"
-version = "0.1.0"
+version = "0.1.2"
 description = "SSB Pubmd"
 authors = ["Olav Landsverk <stud-oll@ssb.no>"]
 license = "MIT"
@@ -9,6 +9,8 @@ homepage = "https://github.com/statisticsnorway/ssb-pubmd"
 repository = "https://github.com/statisticsnorway/ssb-pubmd"
 documentation = "https://statisticsnorway.github.io/ssb-pubmd"
 classifiers = ["Development Status :: 3 - Alpha"]
+include = ["ssb_pubmd/templates"]
+
 
 [tool.poetry.urls]
 Changelog = "https://github.com/statisticsnorway/ssb-pubmd/releases"
@@ -16,11 +18,14 @@ Changelog = "https://github.com/statisticsnorway/ssb-pubmd/releases"
 [tool.poetry.dependencies]
 python = "^3.10"
 requests = "^2.32.4"
-types-requests = "^2.32.4.20250611"
-google-cloud-secret-manager = "^2.24.0"
-pyjwt = "^2.10.1"
-cryptography = "^45.0.5"
 nbformat = "^5.10.4"
+nh3 = "^0.3.2"
+pandocfilters = "^1.5.1"
+ipynbname = "^2025.8.0.0"
+pydantic = "^2.12.5"
+narwhals = "^2.15.0"
+watchfiles = "^1.1.1"
+dapla-auth-client = "^1.2.5"
 
 [tool.poetry.group.dev.dependencies]
 pygments = ">=2.10.0"
@@ -38,6 +43,12 @@ sphinx-click = ">=3.0.2"
 typeguard = ">=2.13.3"
 xdoctest = { extras = ["colors"], version = ">=0.15.10" }
 myst-parser = { version = ">=0.16.1" }
+black = "^25.1.0"
+darglint = "^1.8.1"
+types-requests = "^2.32.4.20260107"
+pandas = "^2.3.3"
+types-pyyaml = "^6.0.12.20250915"
+quarto = "^0.1.0"
 
 [tool.pytest.ini_options]
 pythonpath = ["ssb_pubmd"]
@@ -67,10 +78,10 @@ show_error_context = true
 explicit_package_bases = true
 
 [tool.ruff]
-force-exclude = true  # Apply excludes to pre-commit
+force-exclude = true # Apply excludes to pre-commit
 show-fixes = true
 src = ["src", "tests"]
-target-version = "py311"  # Minimum Python version supported
+target-version = "py311" # Minimum Python version supported
 include = ["*.py", "*.pyi", "**/pyproject.toml", "*.ipynb"]
 extend-exclude = [
     "__pycache__",
@@ -83,57 +94,63 @@ extend-exclude = [
 # Ruff rules may be customized as desired: https://docs.astral.sh/ruff/rules/
 [tool.ruff.lint]
 select = [
-    "A",    # prevent using keywords that clobber python builtins
-    "ANN",  # check type annotations
-    "B",    # bugbear: security warnings
-    "E",    # pycodestyle
-    "F",    # pyflakes
-    "ISC",  # implicit string concatenation
-    "I",    # sort imports
-    "UP",   # alert you when better syntax is available in your python version
-    "RUF",  # the ruff developer's own rules
+    "A",   # prevent using keywords that clobber python builtins
+    "ANN", # check type annotations
+    "B",   # bugbear: security warnings
+    "E",   # pycodestyle
+    "F",   # pyflakes
+    "ISC", # implicit string concatenation
+    "I",   # sort imports
+    "UP",  # alert you when better syntax is available in your python version
+    "RUF", # the ruff developer's own rules
 ]
 ignore = [
-    "ANN202", # Don't requiere return type annotation for private functions.
-    "ANN401", # Allow type annotation with type Any.
-    "D100",   # Supress undocumented-public-module. Only doc of public api required.
-    "FBT001", # Allow boolean positional arguments in a function.
-    "FBT002", # Allow boolean default positional arguments in a function.
-    "E402",   # Supress module-import-not-at-top-of-file, needed in jupyter notebooks.
-    "E501",   # Supress line-too-long warnings: trust black's judgement on this one.
+    "ANN202",  # Don't requiere return type annotation for private functions.
+    "ANN401",  # Allow type annotation with type Any.
+    "D100",    # Supress undocumented-public-module. Only doc of public api required.
+    "FBT001",  # Allow boolean positional arguments in a function.
+    "FBT002",  # Allow boolean default positional arguments in a function.
+    "E402",    # Supress module-import-not-at-top-of-file, needed in jupyter notebooks.
+    "E501",    # Supress line-too-long warnings: trust black's judgement on this one.
     "PLR2004", # Allow to compare with unnamed numerical constants.
 ]
 
 [tool.ruff.lint.isort]
 force-single-line = true
+known-first-party = ["ssb_pubmd"]
 
 [tool.ruff.lint.mccabe]
 max-complexity = 15
 
 [tool.ruff.lint.pydocstyle]
-convention = "google"  # You can also use "numpy".
+convention = "google" # You can also use "numpy".
 
 [tool.ruff.lint.pylint]
 max-args = 8
 
 [tool.ruff.lint.pep8-naming]
-classmethod-decorators = ["classmethod", "validator", "root_validator", "pydantic.validator"]
+classmethod-decorators = [
+    "classmethod",
+    "validator",
+    "root_validator",
+    "pydantic.validator",
+]
 
 [tool.ruff.lint.per-file-ignores]
 "*/__init__.py" = ["F401"]
 "**/tests/*" = [
-    "ANN001",  # type annotations don't add value for test functions
-    "ANN002",  # type annotations don't add value for test functions
-    "ANN003",  # type annotations don't add value for test functions
-    "ANN201",  # type annotations don't add value for test functions
-    "ANN204",  # type annotations don't add value for test functions
-    "ANN205",  # type annotations don't add value for test functions
-    "ANN206",  # type annotations don't add value for test functions
-    "D100",    # docstrings are overkill for test functions
+    "ANN001", # type annotations don't add value for test functions
+    "ANN002", # type annotations don't add value for test functions
+    "ANN003", # type annotations don't add value for test functions
+    "ANN201", # type annotations don't add value for test functions
+    "ANN204", # type annotations don't add value for test functions
+    "ANN205", # type annotations don't add value for test functions
+    "ANN206", # type annotations don't add value for test functions
+    "D100",   # docstrings are overkill for test functions
     "D101",
     "D102",
     "D103",
-    "S101",    # asserts are encouraged in pytest
+    "S101",   # asserts are encouraged in pytest
 ]
 
 [build-system]

ssb_pubmd-0.1.2/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-0.1.2/ssb_pubmd/__main__.py

@@ -0,0 +1,13 @@
+import sys
+
+from ssb_pubmd.cli import run_cli
+from ssb_pubmd.config import get_config
+
+
+def main() -> None:
+    config = get_config()
+    run_cli(sys.argv, config)
+
+
+if __name__ == "__main__":
+    main()

ssb_pubmd-0.1.2/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-0.1.2/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-0.1.2/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-0.1.2/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()