ssb-pubmd 0.0.15__tar.gz → 0.0.17__tar.gz

{ssb_pubmd-0.0.15 → ssb_pubmd-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.15
+Version: 0.0.17
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -14,8 +14,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: click (>=8.0.1)
+Requires-Dist: google-cloud-secret-manager (>=2.24.0,<3.0.0)
 Requires-Dist: nbformat (>=5.10.4,<6.0.0)
+Requires-Dist: platformdirs (>=4.3.8,<5.0.0)
 Requires-Dist: playwright (>=1.51.0,<2.0.0)
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: types-requests (>=2.32.0.20250306,<3.0.0.0)
 Project-URL: Changelog, https://github.com/statisticsnorway/ssb-pubmd/releases

{ssb_pubmd-0.0.15 → ssb_pubmd-0.0.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-pubmd"
-version = "0.0.15"
+version = "0.0.17"
 description = "SSB Pubmd"
 authors = ["Olav Landsverk <stud-oll@ssb.no>"]
 license = "MIT"
@@ -20,6 +20,9 @@ nbformat = "^5.10.4"
 requests = "^2.32.3"
 types-requests = "^2.32.0.20250306"
 playwright = "^1.51.0"
+platformdirs = "^4.3.8"
+pyjwt = "^2.10.1"
+google-cloud-secret-manager = "^2.24.0"
 
 [tool.poetry.group.dev.dependencies]
 pygments = ">=2.10.0"

ssb_pubmd-0.0.17/src/ssb_pubmd/__main__.py

@@ -0,0 +1,161 @@
+"""Command-line interface."""
+
+import json
+import os
+from enum import Enum
+from pathlib import Path
+from typing import cast
+from urllib.parse import urlparse
+
+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 cast(str, value)
+
+    def get_config_file_value() -> str:
+        """Get value from the config file."""
+        with open(CONFIG_FILE) as f:
+            data = json.load(f)
+
+        value = data.get(key)
+
+        return cast(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)
+
+
+if __name__ == "__main__":
+    cli()

{ssb_pubmd-0.0.15 → ssb_pubmd-0.0.17}/src/ssb_pubmd/browser_request_handler.py

@@ -1,12 +1,12 @@
-import os
 from collections.abc import Iterator
 from contextlib import contextmanager
 from enum import Enum
+from pathlib import Path
 
 from playwright.sync_api import BrowserContext
 from playwright.sync_api import sync_playwright
 
-from .markdown_syncer import Response
+from ssb_pubmd.request_handler import Response
 
 
 class CreateContextMethod(Enum):
@@ -23,9 +23,9 @@ class CreateContextMethod(Enum):
 class BrowserRequestHandler:
     """This class is used to create a logged in browser context from which to send requests."""
 
-    def __init__(self, context_file_path: str, login_url: str = "") -> None:
+    def __init__(self, context_file_path: Path, login_url: str) -> None:
         """Initializes an empty browser context object."""
-        self._context_file_path: str = os.path.abspath(context_file_path)
+        self._context_file_path: Path = context_file_path
         self._login_url: str = login_url
         self._context: BrowserContext | None = None
 
@@ -75,7 +75,7 @@ class BrowserRequestHandler:
             body = api_response.json()
             body = dict(body)
         except Exception:
-            body = None
+            body = {}
 
         response = Response(
             status_code=api_response.status,

ssb_pubmd-0.0.17/src/ssb_pubmd/constants.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+from platformdirs import user_cache_path
+from platformdirs import user_config_path
+from platformdirs import user_data_path
+
+APP_NAME = "pubmd"
+
+METADATA_FILE = user_data_path(APP_NAME, ensure_exists=True) / "metadata.json"
+CACHE_FILE = user_cache_path(APP_NAME, ensure_exists=True) / "cache.json"
+CONFIG_FILE = user_config_path(APP_NAME, ensure_exists=True) / "config.json"
+
+CACHE_FILE.touch()
+CONFIG_FILE.touch()
+METADATA_FILE.touch()
+
+
+class ContentType(Enum):
+    """Allowed content types."""
+
+    MARKDOWN = ".md"
+    NOTEBOOK = ".ipynb"

ssb_pubmd-0.0.17/src/ssb_pubmd/jwt_request_handler.py

@@ -0,0 +1,99 @@
+import json
+from dataclasses import dataclass
+from datetime import datetime
+
+import jwt
+import requests
+from google.cloud import secretmanager
+
+from ssb_pubmd.request_handler import Response
+
+TYPE = "JWT"
+ALGORITHM = "RS256"
+
+
+@dataclass
+class SecretData:
+    """Data class to hold private key and connected data."""
+
+    private_key: str
+    kid: str
+    principal_key: str
+
+
+class JWTRequestHandler:
+    """This class is used to send requests with a JSON Web Token (JWT) in the header."""
+
+    def __init__(self, gc_secret_resource_name: str) -> None:
+        """Initializes a JWT request handler object."""
+        self._gc_secret_resource_name: str = gc_secret_resource_name
+
+    def _private_key_from_secret_manager(self) -> SecretData:
+        """Fetches the private key from Google Cloud Secret Manager."""
+        client = secretmanager.SecretManagerServiceClient()
+        print(f"Fetching secret from {self._gc_secret_resource_name}")
+        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:
+            secret_data = SecretData(
+                private_key=data["privateKey"],
+                kid=data["kid"],
+                principal_key=data["principalKey"],
+            )
+        except KeyError as e:
+            raise ValueError(
+                "The secret must be a JSON object with keys 'privateKey', 'kid' and 'principalKey'."
+            ) from e
+        return secret_data
+
+    def _generate_token(self) -> str:
+        secret_data = self._private_key_from_secret_manager()
+
+        header = {
+            "kid": secret_data.kid,
+            "typ": TYPE,
+            "alg": ALGORITHM,
+        }
+
+        iat = int(datetime.now().timestamp())
+        exp = iat + 30
+        payload = {
+            "sub": secret_data.principal_key,
+            "iat": iat,
+            "exp": exp,
+        }
+
+        token = jwt.encode(
+            payload, secret_data.private_key, algorithm=ALGORITHM, headers=header
+        )
+        return token
+
+    def send_request(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        data: dict[str, str] | None = None,
+    ) -> Response:
+        """Sends the request to the specified url with bearer token in header."""
+        token = self._generate_token()
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+        response = requests.post(
+            url,
+            headers=headers,
+            json=data,
+        )
+
+        try:
+            body = response.json()
+            body = dict(body)
+        except Exception:
+            body = {}
+
+        return Response(
+            status_code=response.status_code,
+            body=body,
+        )

{ssb_pubmd-0.0.15 → ssb_pubmd-0.0.17}/src/ssb_pubmd/markdown_syncer.py

@@ -1,79 +1,17 @@
 import json
-import os
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any
-from typing import Protocol
+from pathlib import Path
 
 import nbformat
-import requests
 from nbformat import NotebookNode
 
-
-@dataclass
-class Response:
-    """The expected response object used in this module."""
-
-    status_code: int
-    body: dict[str, Any] | None = None
-
-
-class RequestHandler(Protocol):
-    """Interface for the handling how the request is sent.
-
-    Implementing classes may handle authentication, sessions, etc.
-    """
-
-    def send_request(
-        self,
-        url: str,
-        headers: dict[str, str] | None = None,
-        data: dict[str, str] | None = None,
-    ) -> Response:
-        """Sends the request to the specified url, optionally with headers and data, and returns the response."""
-        ...
-
-
-class BasicRequestHandler:
-    """Basic, unauthenticated request handler."""
-
-    def __init__(self) -> None:
-        """Initializes the basic request handler."""
-        pass
-
-    def send_request(
-        self,
-        url: str,
-        headers: dict[str, str] | None = None,
-        data: dict[str, str] | None = None,
-    ) -> Response:
-        """Sends the request to the specified url without any headers."""
-        response = requests.post(
-            url,
-            data=data,
-        )
-
-        try:
-            body = response.json()
-            body = dict(body)
-        except Exception:
-            body = None
-
-        return Response(
-            status_code=response.status_code,
-            body=body,
-        )
-
-
-class FileType(Enum):
-    """File extensions for markdown and notebook files."""
-
-    MARKDOWN = ".md"
-    NOTEBOOK = ".ipynb"
+from ssb_pubmd.constants import METADATA_FILE
+from ssb_pubmd.constants import ContentType
+from ssb_pubmd.request_handler import RequestHandler
+from ssb_pubmd.request_handler import Response
 
 
 class MarkdownSyncer:
-    """This class syncs a markdown/notebook file to a CMS (Content Management System).
+    """This class syncs a content file to a CMS (Content Management System).
 
     The CMS must have an endpoint that satisfies the following constraints:
 
@@ -91,68 +29,91 @@ class MarkdownSyncer:
 
     ID_KEY = "_id"
 
-    def __init__(self, post_url: str, request_handler: RequestHandler) -> None:
+    def __init__(
+        self,
+        post_url: str,
+        request_handler: RequestHandler,
+        metadata_file: Path = METADATA_FILE,
+    ) -> None:
         """Creates a markdown syncer instance that connects to the CMS through the post url."""
         self._post_url: str = post_url
         self._request_handler: RequestHandler = request_handler
-        self._content_file_path: str = ""
-        self._content_file_type: FileType = FileType.MARKDOWN
+        self._content_file_path: Path = Path()
+        self._content_file_type: ContentType = ContentType.MARKDOWN
+        self._metadata_file_path: Path = metadata_file
 
     @property
-    def content_file_path(self) -> str:
-        """Returns the path of the markdown/notebook file."""
+    def content_file_path(self) -> Path:
+        """Returns the path of the content file."""
         return self._content_file_path
 
     @content_file_path.setter
-    def content_file_path(self, content_file_path: str) -> None:
-        """Sets the path of the markdown/notebook file."""
-        content_file_path = os.path.abspath(content_file_path)
-
-        if not os.path.exists(content_file_path):
-            raise FileNotFoundError(f"The file '{content_file_path}' does not exist.")
-
-        ext = os.path.splitext(content_file_path)[1]
-        for e in FileType:
-            if ext == e.value:
-                self._content_file_type = e
+    def content_file_path(self, path: Path) -> None:
+        """Sets the path of the content file."""
+        if not path.is_file():
+            raise FileNotFoundError(f"The file {path} does not exist.")
+
+        ext = path.suffix.lower()
+        for t in ContentType:
+            if ext == t.value:
+                self._content_file_type = t
                 break
         else:
+            allowed_extensions = [t.value for t in ContentType]
+            sep = ", "
             raise ValueError(
-                f"The file '{content_file_path}' is not a markdown or notebook file."
+                f"The file {path} has extension {ext}, but should be one of: {sep.join(allowed_extensions)}."
             )
 
-        self._content_file_path = content_file_path
+        self._content_file_path = path
 
     @property
     def basename(self) -> str:
-        """The name of the markdown/notebook file without extension."""
-        basename = os.path.basename(self.content_file_path)
-        return os.path.splitext(basename)[0]
-
-    @property
-    def data_path(self) -> str:
-        """The absolute path of the file to store the data returned from the CMS."""
-        return os.path.splitext(self.content_file_path)[0] + "-PUBMD.json"
+        """The name of the content file without extension."""
+        return self._content_file_path.stem
 
     @property
     def display_name(self) -> str:
         """Generate a display name for the content."""
         return self.basename.replace("_", " ").title()
 
+    @property
+    def metadata_file_path(self) -> Path:
+        """The path of the metadata file."""
+        return self._metadata_file_path
+
+    @property
+    def metadata_key(self) -> str:
+        """The key that the content metadata will be stored under in the metadata file."""
+        return str(self._content_file_path.absolute())
+
     def _save_content_id(self, content_id: str) -> None:
-        """Saves the content id to the data file."""
-        filename = self.data_path
-        with open(filename, "w") as file:
-            json.dump({self.ID_KEY: content_id}, file)
+        """Saves the content id to the metadata file."""
+        with open(self._metadata_file_path) as f:
+            try:
+                data = json.load(f)
+            except json.JSONDecodeError:
+                data = {}
+
+        data[self.metadata_key] = {
+            self.ID_KEY: content_id,
+        }
+
+        with open(self._metadata_file_path, "w") as f:
+            json.dump(data, f, indent=4)
 
     def _get_content_id(self) -> str:
-        """Fetches the content id from the data file if it exists, otherwise an empty string."""
-        content_id = ""
+        """Fetches the content id from the metadata file if it exists, otherwise an empty string."""
+        with open(self._metadata_file_path) as f:
+            try:
+                data = json.load(f)
+            except json.JSONDecodeError:
+                data = {}
+
+        metadata: dict[str, str] = data.get(self.metadata_key, {})
+
+        content_id = metadata.get(self.ID_KEY, "")
 
-        filename = self.data_path
-        if os.path.exists(filename):
-            with open(filename) as file:
-                content_id = json.load(file)[self.ID_KEY]
         return content_id
 
     def _read_notebook(self) -> NotebookNode:
@@ -181,9 +142,9 @@ class MarkdownSyncer:
     def _get_content(self) -> str:
         content = ""
         match self._content_file_type:
-            case FileType.MARKDOWN:
+            case ContentType.MARKDOWN:
                 content = self._get_content_from_markdown_file()
-            case FileType.NOTEBOOK:
+            case ContentType.NOTEBOOK:
                 content = self._get_content_from_notebook_file()
         return content
 
@@ -195,7 +156,7 @@ class MarkdownSyncer:
             "markdown": self._get_content(),
         }
 
-    def _send_request(self) -> str:
+    def sync_content(self) -> Response:
         """Sends the request to the CMS endpoint and returns the content id from the response."""
         response = self._request_handler.send_request(
             url=self._post_url, data=self._request_data()
@@ -217,11 +178,6 @@ class MarkdownSyncer:
                 f"Response from the CMS does not contain a valid content id: {result}"
             )
         content_id: str = result
-
-        return content_id
-
-    def sync_content(self) -> str:
-        """Sends the markdown content to the CMS endpoint and stores the id from the response."""
-        content_id = self._send_request()
         self._save_content_id(content_id)
-        return content_id
+
+        return response

ssb_pubmd-0.0.17/src/ssb_pubmd/request_handler.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from typing import Any
+from typing import Protocol
+
+import requests
+
+
+@dataclass
+class Response:
+    """The response object used in the package."""
+
+    status_code: int
+    body: dict[str, Any]
+
+
+class RequestHandler(Protocol):
+    """Interface for handling how a request are sent.
+
+    Implementing classes may handle authentication, sessions, etc.
+    """
+
+    def send_request(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        data: dict[str, str] | None = None,
+    ) -> Response:
+        """Sends the request to the specified url, optionally with headers and data, and returns the response."""
+        ...
+
+
+class BasicRequestHandler:
+    """Basic, unauthenticated request handler."""
+
+    def send_request(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        data: dict[str, str] | None = None,
+    ) -> Response:
+        """Sends the request to the specified url without any headers."""
+        response = requests.post(
+            url,
+            data=data,
+        )
+
+        try:
+            body = response.json()
+            body = dict(body)
+        except Exception:
+            body = {}
+
+        return Response(
+            status_code=response.status_code,
+            body=body,
+        )

ssb_pubmd-0.0.15/src/ssb_pubmd/__main__.py

@@ -1,107 +0,0 @@
-"""Command-line interface."""
-
-import json
-import os
-from dataclasses import asdict
-from dataclasses import dataclass
-
-import click
-
-from ssb_pubmd.browser_request_handler import BrowserRequestHandler
-from ssb_pubmd.browser_request_handler import CreateContextMethod
-from ssb_pubmd.markdown_syncer import MarkdownSyncer
-
-BASE_DIR = os.path.join(os.path.expanduser("~"), ".pubmd")
-os.makedirs(BASE_DIR, exist_ok=True)
-
-CONFIG_PATH = os.path.join(BASE_DIR, "config.json")
-BROWSER_CONTEXT_PATH = os.path.join(BASE_DIR, "browser_context.json")
-
-
-@dataclass
-class Config:
-    """Handles the user configuration."""
-
-    login_url: str = ""
-    post_url: str = ""
-
-    @classmethod
-    def load(cls, path: str) -> "Config":
-        """Loads the configuration from a file."""
-        with open(path) as f:
-            data = json.load(f)
-        return cls(**data)
-
-    def save(self, path: str) -> None:
-        """Saves the configuration to a file."""
-        with open(path, "w") as f:
-            json.dump(asdict(self), f, indent=4)
-
-
-@click.command()
-def config() -> None:
-    """Set the login and post URL for the CMS."""
-    config_file = CONFIG_PATH
-
-    login_url = click.prompt("Enter the login URL", type=str)
-    post_url = click.prompt("Enter the post URL", type=str)
-
-    config = Config(login_url=login_url, post_url=post_url)
-
-    config.save(config_file)
-
-    click.echo(f"\nConfiguration stored in:\n{config_file}")
-
-
-@click.command()
-def login() -> None:
-    """Log in to the CMS application."""
-    config_file = CONFIG_PATH
-    browser_context_file = BROWSER_CONTEXT_PATH
-
-    config = Config.load(config_file)
-    request_handler = BrowserRequestHandler(browser_context_file, config.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{browser_context_file}")
-
-
-@click.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."""
-    config_file = CONFIG_PATH
-    browser_context_file = BROWSER_CONTEXT_PATH
-
-    request_handler = BrowserRequestHandler(browser_context_file)
-
-    with request_handler.new_context():
-        config = Config.load(config_file)
-        syncer = MarkdownSyncer(
-            post_url=config.post_url, request_handler=request_handler
-        )
-
-        syncer.content_file_path = content_file_path
-        content_id = syncer.sync_content()
-
-    click.echo(
-        f"File '{click.format_filename(browser_context_file)}' synced to CMS with content ID: {content_id}."
-    )
-    click.echo(f"Response data saved to '{click.format_filename(syncer.data_path)}'.")
-
-
-@click.group()
-def cli() -> None:
-    """Pubmd - a tool to sync markdown and notebook files to a CMS."""
-    pass
-
-
-cli.add_command(config)
-cli.add_command(login)
-cli.add_command(sync)
-
-if __name__ == "__main__":
-    cli()