ssb-pubmd 0.0.19__py3-none-any.whl → 0.1.1__py3-none-any.whl

ssb_pubmd/__init__.py

@@ -1,6 +1,4 @@
-"""SSB Pubmd."""
+from ssb_pubmd.notebook_client import configure_factbox as Factbox
+from ssb_pubmd.notebook_client import create_highchart as Highchart
 
-from .browser_request_handler import BrowserRequestHandler
-from .markdown_syncer import MarkdownSyncer
-
-__all__ = ["BrowserRequestHandler", "MarkdownSyncer"]
+__all__ = ["Factbox", "Highchart"]

ssb_pubmd/__main__.py

@@ -1,163 +1,13 @@
-"""Command-line interface."""
+import sys
 
-import json
-import os
-from enum import Enum
-from pathlib import Path
-from urllib.parse import urlparse
+from ssb_pubmd.cli import run_cli
+from ssb_pubmd.config import get_config
 
-import click
 
-from ssb_pubmd.browser_request_handler import BrowserRequestHandler
-from ssb_pubmd.browser_request_handler import CreateContextMethod
-from ssb_pubmd.constants import APP_NAME
-from ssb_pubmd.constants import CACHE_FILE
-from ssb_pubmd.constants import CONFIG_FILE
-from ssb_pubmd.jwt_request_handler import JWTRequestHandler
-from ssb_pubmd.markdown_syncer import MarkdownSyncer
-
-
-class ConfigKey(Enum):
-    """Configuration keys for the application."""
-
-    BASE_URL = "base_url"
-    LOGIN_URL = "login_url"
-    POST_URL = "post_url"
-    AUTH_METHOD = "auth_method"
-    GC_SECRET_RESOURCE_NAME = "gc_secret_resource_name"
-
-
-def get_config_value(config_key: ConfigKey) -> str:
-    """Load a configuration value, with precedence environment variable > config file."""
-    key = config_key.value
-
-    def get_env_value() -> str:
-        """Get value from environment variable, by uppercasing the key and adding prefix."""
-        prefix = f"{APP_NAME.upper()}_"
-        value = os.getenv(f"{prefix}{key.upper()}", "")
-
-        return value
-
-    def get_config_file_value() -> str:
-        """Get value from the config file."""
-        try:
-            with open(CONFIG_FILE) as f:
-                data = json.load(f)
-
-            value = data.get(key)
-        except Exception:
-            value = ""
-
-        return str(value)
-
-    return get_env_value() or get_config_file_value()
-
-
-def set_config_value(config_key: ConfigKey, value: str) -> None:
-    """Set a configuration value in the config file."""
-    key = config_key.value
-
-    with open(CONFIG_FILE) as f:
-        try:
-            data = json.load(f)
-        except json.JSONDecodeError:
-            data = {}
-
-    data[key] = value
-
-    with open(CONFIG_FILE, "w") as f:
-        json.dump(data, f, indent=4)
-
-
-@click.group()
-def cli() -> None:
-    """Pubmd - a tool to sync markdown and notebook files to a CMS."""
-    pass
-
-
-@cli.command()
-def settings() -> None:
-    """Set the login and post URL for the CMS."""
-    login_url = click.prompt("Enter the login URL", type=str)
-    set_config_value(ConfigKey.LOGIN_URL, login_url)
-
-    post_url = click.prompt("Enter the post URL", type=str)
-    set_config_value(ConfigKey.POST_URL, post_url)
-
-    click.echo(f"\nSettings stored in:\n{click.format_filename(CONFIG_FILE)}")
-
-
-@cli.command()
-def login() -> None:
-    """Log in to the CMS application."""
-    login_url = get_config_value(ConfigKey.LOGIN_URL)
-    request_handler = BrowserRequestHandler(CACHE_FILE, login_url)
-
-    method = CreateContextMethod.FROM_LOGIN
-    with request_handler.new_context(method=method):
-        click.echo("Logging in...")
-
-    click.echo(f"\nBrowser context stored in:\n{CACHE_FILE}")
-
-
-def sync_with_browser(content_file_path: str) -> None:
-    """Sync a markdown or notebook file to the CMS."""
-    login_url = get_config_value(ConfigKey.LOGIN_URL)
-    request_handler = BrowserRequestHandler(CACHE_FILE, login_url)
-
-    with request_handler.new_context() as context:
-        post_url = get_config_value(ConfigKey.POST_URL)
-        syncer = MarkdownSyncer(post_url, request_handler)
-
-        syncer.content_file_path = Path(content_file_path)
-        response = syncer.sync_content()
-
-        click.echo("Content synced successfully.")
-
-        path = response.body.get("previewPath", "")
-        preview = urlparse(login_url)._replace(path=path).geturl()
-        if preview:
-            page = context.new_page()
-            page.goto(preview)
-            click.echo(f"Preview opened in new browser: {preview}")
-            click.echo("Close the browser tab to finish.")
-            page.wait_for_event("close", timeout=0)
-        else:
-            click.echo("No preview url found in the response.")
-
-
-def sync_with_jwt(content_file_path: str) -> None:
-    """Sync a markdown or notebook file to the CMS."""
-    gc_secret_resource_name = get_config_value(ConfigKey.GC_SECRET_RESOURCE_NAME)
-    request_handler = JWTRequestHandler(gc_secret_resource_name)
-
-    post_url = get_config_value(ConfigKey.POST_URL)
-    syncer = MarkdownSyncer(post_url, request_handler)
-
-    syncer.content_file_path = Path(content_file_path)
-    response = syncer.sync_content()
-
-    click.echo("Content synced successfully.")
-
-    preview_path = response.body.get("previewPath", "")
-    if preview_path:
-        base_url = get_config_value(ConfigKey.BASE_URL)
-        preview = urlparse(base_url)._replace(path=preview_path).geturl()
-        click.echo(f"Preview url found in the response: {preview}")
-    else:
-        click.echo("No preview url found in the response.")
-
-
-@cli.command()
-@click.argument("content_file_path", type=click.Path())
-def sync(content_file_path: str) -> None:
-    """Sync a markdown or notebook file to the CMS."""
-    auth_method = get_config_value(ConfigKey.AUTH_METHOD)
-    if auth_method == "browser":
-        sync_with_browser(content_file_path)
-    else:
-        sync_with_jwt(content_file_path)
+def main() -> None:
+    config = get_config()
+    run_cli(sys.argv, config)
 
 
 if __name__ == "__main__":
-    cli()
+    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()