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

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

@@ -1,27 +1,24 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.19
+Version: 0.1.0
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
 Author-email: stud-oll@ssb.no
 Requires-Python: >=3.10,<4.0
-Classifier: Development Status :: 1 - Planning
+Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 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: click (>=8.0.1)
-Requires-Dist: cryptography (>=45.0.4,<46.0.0)
+Requires-Dist: cryptography (>=45.0.5,<46.0.0)
 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)
+Requires-Dist: requests (>=2.32.4,<3.0.0)
+Requires-Dist: types-requests (>=2.32.4.20250611,<3.0.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
@@ -55,28 +52,25 @@ Description-Content-Type: text/markdown
 [black]: https://github.com/psf/black
 [poetry]: https://python-poetry.org/
 
+## Features
 
-## Installation
+- TODO
 
-Installation with pip:
+## Requirements
 
-```console
-pip install ssb-pubmd
-```
+- TODO
+
+## Installation
 
-If you need to create a logged-in browser context, you will also need to install a [Playwright browser](https://playwright.dev/python/docs/browsers#install-browsers):
+You can install _SSB Pubmd_ via [pip] from [PyPI]:
 
 ```console
-playwright install --with-deps chromium
+pip install ssb-pubmd
 ```
 
 ## Usage
 
-Run the main command in a terminal to see available subcommands with documentation:
-
-```console
-pubmd
-```
+Please see the [Reference Guide] for details.
 
 ## Contributing
 

{ssb_pubmd-0.0.19 → ssb_pubmd-0.1.0}/README.md

@@ -25,28 +25,25 @@
 [black]: https://github.com/psf/black
 [poetry]: https://python-poetry.org/
 
+## Features
 
-## Installation
+- TODO
 
-Installation with pip:
+## Requirements
 
-```console
-pip install ssb-pubmd
-```
+- TODO
+
+## Installation
 
-If you need to create a logged-in browser context, you will also need to install a [Playwright browser](https://playwright.dev/python/docs/browsers#install-browsers):
+You can install _SSB Pubmd_ via [pip] from [PyPI]:
 
 ```console
-playwright install --with-deps chromium
+pip install ssb-pubmd
 ```
 
 ## Usage
 
-Run the main command in a terminal to see available subcommands with documentation:
-
-```console
-pubmd
-```
+Please see the [Reference Guide] for details.
 
 ## Contributing
 

{ssb_pubmd-0.0.19 → ssb_pubmd-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-pubmd"
-version = "0.0.19"
+version = "0.1.0"
 description = "SSB Pubmd"
 authors = ["Olav Landsverk <stud-oll@ssb.no>"]
 license = "MIT"
@@ -8,28 +8,23 @@ readme = "README.md"
 homepage = "https://github.com/statisticsnorway/ssb-pubmd"
 repository = "https://github.com/statisticsnorway/ssb-pubmd"
 documentation = "https://statisticsnorway.github.io/ssb-pubmd"
-classifiers = ["Development Status :: 1 - Planning"]
+classifiers = ["Development Status :: 3 - Alpha"]
 
 [tool.poetry.urls]
 Changelog = "https://github.com/statisticsnorway/ssb-pubmd/releases"
 
 [tool.poetry.dependencies]
 python = "^3.10"
-click = ">=8.0.1"
-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"
+requests = "^2.32.4"
+types-requests = "^2.32.4.20250611"
 google-cloud-secret-manager = "^2.24.0"
-cryptography = "^45.0.4"
+pyjwt = "^2.10.1"
+cryptography = "^45.0.5"
+nbformat = "^5.10.4"
 
 [tool.poetry.group.dev.dependencies]
 pygments = ">=2.10.0"
-black = { extras = ["jupyter"], version = ">=23.1.0" }
 coverage = { extras = ["toml"], version = ">=6.2" }
-darglint = ">=1.8.1"
 furo = ">=2021.11.12"
 mypy = ">=0.930"
 pre-commit = ">=2.16.0"
@@ -43,18 +38,15 @@ sphinx-click = ">=3.0.2"
 typeguard = ">=2.13.3"
 xdoctest = { extras = ["colors"], version = ">=0.15.10" }
 myst-parser = { version = ">=0.16.1" }
-uuid = "^1.30"
-ipykernel = "^6.29.5"
-pytest-asyncio = "^0.26.0"
 
 [tool.pytest.ini_options]
-pythonpath = ["src"]
+pythonpath = ["ssb_pubmd"]
 
 [tool.poetry.scripts]
-pubmd = "ssb_pubmd.__main__:cli"
+ssb-pubmd = "ssb_pubmd.__main__:main"
 
 [tool.coverage.paths]
-source = ["src", "*/site-packages"]
+source = ["ssb_pubmd", "*/site-packages"]
 tests = ["tests", "*/tests"]
 
 [tool.coverage.run]
@@ -72,6 +64,7 @@ warn_unreachable = true
 pretty = true
 show_column_numbers = true
 show_error_context = true
+explicit_package_bases = true
 
 [tool.ruff]
 force-exclude = true  # Apply excludes to pre-commit
@@ -93,7 +86,6 @@ select = [
     "A",    # prevent using keywords that clobber python builtins
     "ANN",  # check type annotations
     "B",    # bugbear: security warnings
-    "D",    # documentation
     "E",    # pycodestyle
     "F",    # pyflakes
     "ISC",  # implicit string concatenation

ssb_pubmd-0.1.0/ssb_pubmd/__main__.py

@@ -0,0 +1,24 @@
+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.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)
+
+
+if __name__ == "__main__":
+    main()

ssb_pubmd-0.1.0/ssb_pubmd/adapters/cli.py

@@ -0,0 +1,21 @@
+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-0.1.0/ssb_pubmd/adapters/cms_client.py

@@ -0,0 +1,47 @@
+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-0.1.0/ssb_pubmd/adapters/local_storage.py

@@ -0,0 +1,72 @@
+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-0.1.0/ssb_pubmd/adapters/secret_manager_client.py

@@ -0,0 +1,66 @@
+"""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-0.1.0/ssb_pubmd/config.py

@@ -0,0 +1,27 @@
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+APP_NAME = "SSB_PUBMD"
+
+
+@dataclass
+class Config:
+    metadata_file_path: Path
+    cms_base_url: str
+    gc_secret_resource_name: str
+
+
+def get_config(metadata_file_path: Path | None = None) -> Config:
+    user_data_dir = Path.home() / ".local" / "share" / APP_NAME
+    if not metadata_file_path:
+        user_data_dir.mkdir(parents=True, exist_ok=True)
+        metadata_file_path = user_data_dir / "metadata.json"
+    if not metadata_file_path.exists():
+        with open(metadata_file_path, "x") as metadata_file:
+            metadata_file.write("{}\n")
+    return Config(
+        metadata_file_path=metadata_file_path,
+        cms_base_url=os.environ[f"{APP_NAME}_BASE_URL"],
+        gc_secret_resource_name=os.environ[f"{APP_NAME}_GC_SECRET_RESOURCE_NAME"],
+    )

ssb_pubmd-0.1.0/ssb_pubmd/enonic_cms_manager.py

@@ -0,0 +1,30 @@
+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-0.1.0/ssb_pubmd/models.py

@@ -0,0 +1,28 @@
+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-0.1.0/ssb_pubmd/ports.py

@@ -0,0 +1,57 @@
+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.0.19/src/ssb_pubmd/__init__.py

@@ -1,6 +0,0 @@
-"""SSB Pubmd."""
-
-from .browser_request_handler import BrowserRequestHandler
-from .markdown_syncer import MarkdownSyncer
-
-__all__ = ["BrowserRequestHandler", "MarkdownSyncer"]

ssb_pubmd-0.0.19/src/ssb_pubmd/__main__.py

@@ -1,163 +0,0 @@
-"""Command-line interface."""
-
-import json
-import os
-from enum import Enum
-from pathlib import Path
-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 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)
-
-
-if __name__ == "__main__":
-    cli()

ssb_pubmd-0.0.19/src/ssb_pubmd/browser_request_handler.py

@@ -1,85 +0,0 @@
-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 ssb_pubmd.request_handler import Response
-
-
-class CreateContextMethod(Enum):
-    """The method used to create the browser context.
-
-    Can be either from a file containing the context data,
-        or from a login popup window.
-    """
-
-    FROM_FILE = "from_file"
-    FROM_LOGIN = "from_login"
-
-
-class BrowserRequestHandler:
-    """This class is used to create a logged in browser context from which to send requests."""
-
-    def __init__(self, context_file_path: Path, login_url: str) -> None:
-        """Initializes an empty browser context object."""
-        self._context_file_path: Path = context_file_path
-        self._login_url: str = login_url
-        self._context: BrowserContext | None = None
-
-    @contextmanager
-    def new_context(
-        self, method: CreateContextMethod = CreateContextMethod.FROM_FILE
-    ) -> Iterator[BrowserContext]:
-        """Wrapper around playwright's context manager.
-
-        The default is to create a new context from a file.
-        If `from_file` is  set False, a new context is created through a browser popup with user login,
-            and the context is saved to a file.
-        """
-        with sync_playwright() as playwright:
-            browser = playwright.chromium.launch(headless=False)
-            match method:
-                case CreateContextMethod.FROM_FILE:
-                    self._context = browser.new_context(
-                        storage_state=self._context_file_path
-                    )
-                case CreateContextMethod.FROM_LOGIN:
-                    self._context = browser.new_context()
-                    login_page = self._context.new_page()
-                    login_page.goto(self._login_url)
-                    login_page.wait_for_event("close", timeout=0)
-                    self._context.storage_state(path=self._context_file_path)
-            yield self._context
-            self._context.close()
-            browser.close()
-
-    def send_request(
-        self,
-        url: str,
-        headers: dict[str, str] | None = None,
-        data: dict[str, str] | None = None,
-    ) -> Response:
-        """Sends a request to the specified url, optionally with headers and data, within the browser context."""
-        if self._context is None:
-            raise ValueError("Browser context has not been created.")
-
-        api_response = self._context.request.post(
-            url,
-            data=data,
-        )
-
-        try:
-            body = api_response.json()
-            body = dict(body)
-        except Exception:
-            body = {}
-
-        response = Response(
-            status_code=api_response.status,
-            body=body,
-        )
-
-        return response

ssb_pubmd-0.0.19/src/ssb_pubmd/constants.py

@@ -1,22 +0,0 @@
-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.19/src/ssb_pubmd/jwt_request_handler.py

@@ -1,99 +0,0 @@
-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.19/src/ssb_pubmd/markdown_syncer.py

@@ -1,183 +0,0 @@
-import json
-from pathlib import Path
-
-import nbformat
-from nbformat import NotebookNode
-
-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 content file to a CMS (Content Management System).
-
-    The CMS must have an endpoint that satisfies the following constraints:
-
-    -   It must accept a post request with fields *_id*, *displayName* and *markdown*.
-    -   The response body must have a key *_id* whose value should be
-        a unique string identifier of the content.
-
-    Creating and updating content is handled in the following way:
-
-    -   On the first request, an empty string is sent as *_id*.
-    -   If the request succeeds, the value of *_id* (in the response) is stored in a JSON file
-        (created in the same directory as the markdown/notebook file).
-    -   On subsequent requests, the stored value is sent as *_id*.
-    """
-
-    ID_KEY = "_id"
-
-    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: Path = Path()
-        self._content_file_type: ContentType = ContentType.MARKDOWN
-        self._metadata_file_path: Path = metadata_file
-
-    @property
-    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, 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 {path} has extension {ext}, but should be one of: {sep.join(allowed_extensions)}."
-            )
-
-        self._content_file_path = path
-
-    @property
-    def basename(self) -> str:
-        """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 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 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, "")
-
-        return content_id
-
-    def _read_notebook(self) -> NotebookNode:
-        """Reads the notebook file and returns its content."""
-        return nbformat.read(self._content_file_path, as_version=nbformat.NO_CONVERT)  # type: ignore
-
-    def _get_content_from_notebook_file(self) -> str:
-        """Extracts all markdown cells from the notebook and returns it as a merged string."""
-        notebook = self._read_notebook()
-
-        markdown_cells = []
-        for cell in notebook.cells:
-            if cell.cell_type == "markdown":
-                markdown_cells.append(cell.source)
-
-        markdown_content = "\n\n".join(markdown_cells)
-
-        return markdown_content
-
-    def _get_content_from_markdown_file(self) -> str:
-        """Returns the content of a markdown file."""
-        with open(self._content_file_path) as file:
-            markdown_content = file.read()
-        return markdown_content
-
-    def _get_content(self) -> str:
-        content = ""
-        match self._content_file_type:
-            case ContentType.MARKDOWN:
-                content = self._get_content_from_markdown_file()
-            case ContentType.NOTEBOOK:
-                content = self._get_content_from_notebook_file()
-        return content
-
-    def _request_data(self) -> dict[str, str]:
-        """Prepares the request data to be sent to the CMS endpoint."""
-        return {
-            "_id": self._get_content_id(),
-            "displayName": self.display_name,
-            "markdown": self._get_content(),
-        }
-
-    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()
-        )
-
-        if response.status_code != 200:
-            raise ValueError(
-                f"Request to the CMS failed with status code {response.status_code}."
-            )
-        if response.body is None:
-            raise ValueError("Response body from CMS could not be parsed.")
-        if self.ID_KEY not in response.body:
-            raise ValueError(
-                f"Response from the CMS does not contain the expected key '{self.ID_KEY}'."
-            )
-        result = response.body[self.ID_KEY]
-        if not isinstance(result, str):
-            raise ValueError(
-                f"Response from the CMS does not contain a valid content id: {result}"
-            )
-        content_id: str = result
-        self._save_content_id(content_id)
-
-        return response

ssb_pubmd-0.0.19/src/ssb_pubmd/request_handler.py

@@ -1,56 +0,0 @@
-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,
-        )