ssb-pubmd 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

ssb_pubmd/__init__.py

@@ -1,5 +1,6 @@
 """SSB Pubmd."""
 
-from .exporter import notebook_to_cms
+from .browser_context import BrowserRequestContext as BrowserContext
+from .notebook_syncer import NotebookSyncer
 
-__all__ = ["notebook_to_cms"]
+__all__ = ["BrowserContext", "NotebookSyncer"]

ssb_pubmd/browser_context.py

@@ -0,0 +1,70 @@
+from typing import cast
+
+from playwright.async_api import BrowserContext
+from playwright.async_api import async_playwright
+
+from .notebook_syncer import Response
+
+
+class BrowserRequestContext:
+    """Creates a logged in browser context from which to send requests."""
+
+    def __init__(self) -> None:
+        """Initializes a browser context with a login url."""
+        self._storage_state_path: str = "browser_context.json"
+        self._context: BrowserContext | None = None
+
+    async def create_new(self, login_url: str) -> BrowserContext:
+        """Creates a browser context by opening a logging page and waiting for it to be closed by user."""
+        playwright = await async_playwright().start()
+        browser = await playwright.chromium.launch(headless=False)
+
+        self._context = await browser.new_context()
+        login_page = await self._context.new_page()
+
+        await login_page.goto(login_url)
+        await login_page.wait_for_event("close", timeout=0)
+
+        await self._context.storage_state(path=self._storage_state_path)
+
+        return self._context
+
+    async def recreate_from_file(self) -> BrowserContext:
+        """Restores a browser context from the storage state file."""
+        playwright = await async_playwright().start()
+        browser = await playwright.chromium.launch(headless=False)
+
+        self._context = await browser.new_context(
+            storage_state=self._storage_state_path
+        )
+
+        return self._context
+
+    async def send_request(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        data: dict[str, str] | None = None,
+    ) -> Response:
+        """Sends a request tp 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.")
+
+        params = cast(dict[str, str | float | bool], data)
+        api_response = await self._context.request.post(
+            url,
+            params=params,
+        )
+
+        try:
+            body = await api_response.json()
+            body = dict(body)
+        except Exception:
+            body = None
+
+        response = Response(
+            status_code=api_response.status,
+            body=body,
+        )
+
+        return response

ssb_pubmd/notebook_syncer.py

@@ -0,0 +1,193 @@
+import json
+import os
+from dataclasses import dataclass
+from typing import Any
+from typing import Protocol
+
+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 RequestContext(Protocol):
+    """Interface for the context in which a request is sent.
+
+    Implementing classes may handle authentication, session management, etc.
+    """
+
+    async 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 BasicRequestContext:
+    """Basic, unauthenticated request context."""
+
+    def __init__(self) -> None:
+        """Initializes the basic request context."""
+        pass
+
+    async 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 NotebookSyncer:
+    """Utility class that helps syncing a notebook 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 notebook file).
+    -   On subsequent requests, the stored value is sent as *_id*.
+    """
+
+    ID_KEY = "_id"
+
+    def __init__(self, post_url: str, request_context: RequestContext) -> None:
+        """Creates a notebook syncer instance that connects to the CMS through the post url."""
+        self._post_url: str = post_url
+        self._context: RequestContext = request_context
+        self._notebook_path: str = ""
+
+    @property
+    def notebook_path(self) -> str:
+        """Returns the path of the notebook file."""
+        return self._notebook_path
+
+    @notebook_path.setter
+    def notebook_path(self, notebook_path: str) -> None:
+        """Sets the path of the notebook file."""
+        notebook_path = os.path.abspath(notebook_path)
+        if not os.path.exists(notebook_path):
+            raise FileNotFoundError(
+                f"The notebook file '{notebook_path}' does not exist."
+            )
+        self._notebook_path = notebook_path
+
+    @property
+    def basename(self) -> str:
+        """The name of the notebook file without extension."""
+        basename = os.path.basename(self.notebook_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.notebook_path)[0] + ".json"
+
+    @property
+    def display_name(self) -> str:
+        """Generate a display name for the content."""
+        return self.basename.replace("_", " ").title()
+
+    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)
+
+    def _get_content_id(self) -> str:
+        """Returns the content id from the data file if it exists, otherwise an empty string."""
+        content_id = ""
+
+        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:
+        """Reads the notebook file and returns its content."""
+        return nbformat.read(self._notebook_path, as_version=nbformat.NO_CONVERT)  # type: ignore
+
+    def _get_content_from_notebook(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 _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_from_notebook(),
+        }
+
+    async def _send_request(self) -> str:
+        """Sends the request to the CMS endpoint and returns the content id from the response."""
+        response = await self._context.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
+
+        return content_id
+
+    async def sync_content(self) -> str:
+        """Sends the notebook content to the CMS endpoint and stores the id from the response."""
+        content_id = await self._send_request()
+        self._save_content_id(content_id)
+        return content_id

{ssb_pubmd-0.0.8.dist-info → ssb_pubmd-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.8
+Version: 0.0.9
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: click (>=8.0.1)
 Requires-Dist: nbformat (>=5.10.4,<6.0.0)
+Requires-Dist: playwright (>=1.51.0,<2.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
@@ -52,11 +53,12 @@ Description-Content-Type: text/markdown
 
 ## Features
 
-- TODO
+- Helper library for syncing a Jupyter Notebook with a remote server (e.g. a CMS/publishing platform).
+- Supports logging in through a popup browser window.
 
 ## Requirements
 
-- TODO
+- This library uses [playwright](https://github.com/microsoft/playwright-python) to create a logged in browser context. This requires installing a [browser binary](https://playwright.dev/python/docs/browsers#install-browsers) and necessary [system dependencies](https://playwright.dev/python/docs/browsers#install-system-dependencies).
 
 ## Installation
 

ssb_pubmd-0.0.9.dist-info/RECORD

@@ -0,0 +1,10 @@
+ssb_pubmd/__init__.py,sha256=bEVVJ-sm5MmH5bXnzzyek_nSAvutyB0WNpBy835lE2g,179
+ssb_pubmd/__main__.py,sha256=8D0yedPhnV_2L7nj0s0KUKxNQqPxoussMHGDNM-vyjg,209
+ssb_pubmd/browser_context.py,sha256=V4KyL9Ell2xlW5LnDFQNa0p16TDCnOEXduYtH1UW4p0,2309
+ssb_pubmd/notebook_syncer.py,sha256=w0SXHaT5Ubxzs1CfGHdbe6kW1vqHz7HgY90ZZK1Py0M,6537
+ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ssb_pubmd-0.0.9.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
+ssb_pubmd-0.0.9.dist-info/METADATA,sha256=ZIJBSX_aNAPyBjkKvdncKxl8BAox_QvYQY7nOJftjPI,4406
+ssb_pubmd-0.0.9.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+ssb_pubmd-0.0.9.dist-info/entry_points.txt,sha256=o4oU99zbZNIBKGYWdgdEG6ev-62ZRWEJOe7EOjJaajk,53
+ssb_pubmd-0.0.9.dist-info/RECORD,,

ssb_pubmd/exporter.py

@@ -1,140 +0,0 @@
-import json
-import os
-
-import nbformat
-import requests
-from nbformat import NotebookNode
-
-
-class _Exporter:
-    """Helper class for exporting notebook content."""
-
-    ID_KEY = "_id"
-
-    def __init__(self, post_url: str) -> None:
-        self.post_url: str = post_url
-        self.notebook_folder: str = ""
-        self.notebook_filename: str = ""
-
-    @property
-    def parent_folder(self) -> str:
-        """The parent folder path, defaults to current working directory."""
-        if self.notebook_folder:
-            return self.notebook_folder
-        else:
-            return os.getcwd()
-
-    @property
-    def notebook_path(self) -> str:
-        """The absolute path of the notebook file."""
-        return os.path.join(self.parent_folder, self.notebook_filename)
-
-    @property
-    def basename(self) -> str:
-        """The name of the notebook file without extension."""
-        return os.path.splitext(self.notebook_filename)[0]
-
-    @property
-    def data_path(self) -> str:
-        """The absolute path of the file to store data returned from the CMS."""
-        return os.path.join(self.parent_folder, self.basename + ".json")
-
-    @property
-    def display_name(self) -> str:
-        """Generate a display name for the content."""
-        return self.basename.replace("_", " ").title()
-
-    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)
-
-    def _get_content_id(self) -> str:
-        """Returns the content id from the data file if it exists, otherwise an empty string."""
-        content_id = ""
-
-        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:
-        """Reads the notebook file and returns its content."""
-        return nbformat.read(self.notebook_path, as_version=nbformat.NO_CONVERT)  # type: ignore
-
-    def _get_content_from_notebook(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 _request_data(self) -> dict[str, str]:
-        """Prepares the request data to be sent to the CMS post_url."""
-        return {
-            "_id": self._get_content_id(),
-            "displayName": self.display_name,
-            "markdown": self._get_content_from_notebook(),
-        }
-
-    def _send_request(self) -> str:
-        """Sends the request to the CMS endpoint and returns the content id from the response."""
-        response = requests.post(
-            self.post_url,
-            data=self._request_data(),
-        )
-        content_id = response.json()[self.ID_KEY]
-        return content_id  # type: ignore
-
-    def set_notebook(self, notebook_filename: str, notebook_folder: str) -> None:
-        """Sets the notebook filename and notebook folder."""
-        self.notebook_filename = notebook_filename
-        self.notebook_folder = notebook_folder
-
-    def export(self) -> str:
-        """Main method to export the notebook content to the CMS post_url."""
-        content_id = self._send_request()
-        self._save_content_id(content_id)
-        return content_id
-
-
-def notebook_to_cms(
-    post_url: str,
-    notebook_filename: str,
-    notebook_folder: str = "",
-) -> str:
-    r"""Sends all the markdown content of a notebook to a CMS endpoint.
-
-    The CMS endpoint must satisfy two 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 notebook file).
-    -   On subsequent requests, the stored value is sent as *id*.
-
-    Args:
-        post_url (str): The URL of the CMS endpoint.
-        notebook_filename (str): The name of the notebook file, e.g. `"my_notebook.ipynb"`.
-        notebook_folder (str): Sets a custom notebook folder (as absolute path) containing the notebook file.
-            If not set, the current folder is used.
-
-    Returns:
-        str: The identifier of the content returned by the CMS endpoint.
-    """
-    exporter = _Exporter(post_url)
-    exporter.set_notebook(notebook_filename, notebook_folder)
-    return exporter.export()

ssb_pubmd-0.0.8.dist-info/RECORD

@@ -1,9 +0,0 @@
-ssb_pubmd/__init__.py,sha256=2ivKDmqp2ZqJDgVfcUaA8A3-ahUJj-h3RMktSTzMIMw,87
-ssb_pubmd/__main__.py,sha256=8D0yedPhnV_2L7nj0s0KUKxNQqPxoussMHGDNM-vyjg,209
-ssb_pubmd/exporter.py,sha256=73l1rOMIXwV5yqTjifuuPfHlBsqngou3lmggVzMXuKA,4974
-ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ssb_pubmd-0.0.8.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
-ssb_pubmd-0.0.8.dist-info/METADATA,sha256=X3UeJFn9kFqOm6nJkpzf2Y2-JVJQDD1uixXHk8JW97g,3883
-ssb_pubmd-0.0.8.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-ssb_pubmd-0.0.8.dist-info/entry_points.txt,sha256=o4oU99zbZNIBKGYWdgdEG6ev-62ZRWEJOe7EOjJaajk,53
-ssb_pubmd-0.0.8.dist-info/RECORD,,