ssb-pubmd 0.0.10__tar.gz → 0.0.12__tar.gz

{ssb_pubmd-0.0.10 → ssb_pubmd-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.10
+Version: 0.0.12
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -53,7 +53,6 @@ Description-Content-Type: text/markdown
 
 ## Features
 
-- 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
@@ -70,7 +69,28 @@ pip install ssb-pubmd
 
 ## Usage
 
-Please see the [Reference Guide] for details.
+First set environment variables:
+
+```console
+export PUBMD_LOGIN_URL=<https://www.example.com/login>
+export PUBMD_POST_URL=<https://www.example.com/post>
+```
+
+To log in, run:
+
+```console
+pubmd login
+```
+
+Close the popup browser window when you are logged in.
+
+To synchronize markdown content to the CMS server, run:
+
+```console
+pubmd sync <file>
+```
+
+`<file>` should be an absolute or relative path, and the allowed extensions are `.ipynb` and `md`.
 
 ## Contributing
 

{ssb_pubmd-0.0.10 → ssb_pubmd-0.0.12}/README.md

@@ -27,7 +27,6 @@
 
 ## Features
 
-- 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
@@ -44,7 +43,28 @@ pip install ssb-pubmd
 
 ## Usage
 
-Please see the [Reference Guide] for details.
+First set environment variables:
+
+```console
+export PUBMD_LOGIN_URL=<https://www.example.com/login>
+export PUBMD_POST_URL=<https://www.example.com/post>
+```
+
+To log in, run:
+
+```console
+pubmd login
+```
+
+Close the popup browser window when you are logged in.
+
+To synchronize markdown content to the CMS server, run:
+
+```console
+pubmd sync <file>
+```
+
+`<file>` should be an absolute or relative path, and the allowed extensions are `.ipynb` and `md`.
 
 ## Contributing
 

{ssb_pubmd-0.0.10 → ssb_pubmd-0.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-pubmd"
-version = "0.0.10"
+version = "0.0.12"
 description = "SSB Pubmd"
 authors = ["Olav Landsverk <stud-oll@ssb.no>"]
 license = "MIT"
@@ -47,7 +47,7 @@ pytest-asyncio = "^0.26.0"
 pythonpath = ["src"]
 
 [tool.poetry.scripts]
-ssb-pubmd = "ssb_pubmd.__main__:main"
+pubmd = "ssb_pubmd.__main__:cli"
 
 [tool.coverage.paths]
 source = ["src", "*/site-packages"]

ssb_pubmd-0.0.12/src/ssb_pubmd/__init__.py

@@ -0,0 +1,6 @@
+"""SSB Pubmd."""
+
+from .browser_context import BrowserRequestContext as BrowserContext
+from .markdown_syncer import MarkdownSyncer
+
+__all__ = ["BrowserContext", "MarkdownSyncer"]

ssb_pubmd-0.0.12/src/ssb_pubmd/__main__.py

@@ -0,0 +1,52 @@
+"""Command-line interface."""
+
+import os
+
+import click
+
+from ssb_pubmd.browser_context import BrowserRequestContext as RequestContext
+from ssb_pubmd.markdown_syncer import MarkdownSyncer
+
+
+@click.group()
+def cli() -> None:
+    """Command-line interface for the ssb_pubmd package."""
+    pass
+
+
+@click.command()
+def login() -> None:
+    """Login to the server."""
+    login_url = os.getenv("PUBMD_LOGIN_URL", "")
+    request_context = RequestContext()
+    print(login_url)
+    storage_state_file, storage_state = request_context.create_new(login_url)
+    click.echo(
+        f"The following browser context object is now stored in {storage_state_file}:"
+    )
+    click.echo(storage_state)
+
+
+@click.command()
+@click.argument("content_file_path", type=click.Path())
+def sync(content_file_path: str) -> None:
+    """Sync the content."""
+    post_url = os.getenv("PUBMD_POST_URL", "")
+    request_context = RequestContext()
+    request_context.recreate_from_file()
+
+    syncer = MarkdownSyncer(post_url=post_url, request_context=request_context)
+    syncer.content_file_path = content_file_path
+
+    content_id = syncer.sync_content()
+
+    click.echo(
+        f"File '{click.format_filename(content_file_path)}' synced to CMS with content ID: {content_id}"
+    )
+
+
+cli.add_command(login)
+cli.add_command(sync)
+
+if __name__ == "__main__":
+    cli()  # pragma: no cover

ssb_pubmd-0.0.12/src/ssb_pubmd/browser_context.py

@@ -0,0 +1,71 @@
+from playwright.sync_api import BrowserContext
+from playwright.sync_api import StorageState
+from playwright.sync_api import sync_playwright
+
+from .markdown_syncer import Response
+
+BROWSER_CONTEXT_FILE = "browser_context.json"
+
+
+class BrowserRequestContext:
+    """This class is used to create a logged in browser context from which to send requests."""
+
+    def __init__(self) -> None:
+        """Initializes an empty browser context object."""
+        self._storage_state_path: str = BROWSER_CONTEXT_FILE
+        self._context: BrowserContext | None = None
+
+    def create_new(self, login_url: str) -> tuple[str, StorageState]:
+        """Creates a browser context by opening a login page and waiting for it to be closed by user.
+
+        This function also saves the browser context to a file for later use.
+        """
+        playwright = sync_playwright().start()
+        browser = playwright.chromium.launch(headless=False)
+
+        self._context = browser.new_context()
+        login_page = self._context.new_page()
+
+        login_page.goto(login_url)
+        login_page.wait_for_event("close", timeout=0)
+
+        storage_state = self._context.storage_state(path=self._storage_state_path)
+
+        return self._storage_state_path, storage_state
+
+    def recreate_from_file(self) -> BrowserContext:
+        """Recreates a browser context object from a file."""
+        playwright = sync_playwright().start()
+        browser = playwright.chromium.launch(headless=False)
+
+        self._context = browser.new_context(storage_state=self._storage_state_path)
+
+        return self._context
+
+    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,
+            params=data,
+        )
+
+        try:
+            body = api_response.json()
+            body = dict(body)
+        except Exception:
+            body = None
+
+        response = Response(
+            status_code=api_response.status,
+            body=body,
+        )
+
+        return response

ssb_pubmd-0.0.10/src/ssb_pubmd/notebook_syncer.py → ssb_pubmd-0.0.12/src/ssb_pubmd/markdown_syncer.py

@@ -1,6 +1,7 @@
 import json
 import os
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any
 from typing import Protocol
 
@@ -23,7 +24,7 @@ class RequestContext(Protocol):
     Implementing classes may handle authentication, sessions, etc.
     """
 
-    async def send_request(
+    def send_request(
         self,
         url: str,
         headers: dict[str, str] | None = None,
@@ -40,7 +41,7 @@ class BasicRequestContext:
         """Initializes the basic request context."""
         pass
 
-    async def send_request(
+    def send_request(
         self,
         url: str,
         headers: dict[str, str] | None = None,
@@ -64,8 +65,15 @@ class BasicRequestContext:
         )
 
 
-class NotebookSyncer:
-    """This class syncs a notebook to a CMS (Content Management System).
+class FileType(Enum):
+    """File extensions for markdown and notebook files."""
+
+    MARKDOWN = ".md"
+    NOTEBOOK = ".ipynb"
+
+
+class MarkdownSyncer:
+    """This class syncs a markdown/notebook file to a CMS (Content Management System).
 
     The CMS must have an endpoint that satisfies the following constraints:
 
@@ -77,43 +85,54 @@ class NotebookSyncer:
 
     -   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).
+        (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_context: RequestContext) -> None:
-        """Creates a notebook syncer instance that connects to the CMS through the post url."""
+        """Creates a markdown 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 = ""
+        self._content_file_path: str = ""
+        self._content_file_type: FileType = FileType.MARKDOWN
 
     @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."
+    def content_file_path(self) -> str:
+        """Returns the path of the markdown/notebook 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
+                break
+        else:
+            raise ValueError(
+                f"The file '{content_file_path}' is not a markdown or notebook file."
             )
-        self._notebook_path = notebook_path
+
+        self._content_file_path = content_file_path
 
     @property
     def basename(self) -> str:
-        """The name of the notebook file without extension."""
-        basename = os.path.basename(self.notebook_path)
+        """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.notebook_path)[0] + ".json"
+        return os.path.splitext(self.content_file_path)[0] + ".json"
 
     @property
     def display_name(self) -> str:
@@ -138,9 +157,9 @@ class NotebookSyncer:
 
     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
+        return nbformat.read(self._content_file_path, as_version=nbformat.NO_CONVERT)  # type: ignore
 
-    def _get_content_from_notebook(self) -> str:
+    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()
 
@@ -153,17 +172,32 @@ class NotebookSyncer:
 
         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 FileType.MARKDOWN:
+                content = self._get_content_from_markdown_file()
+            case FileType.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_from_notebook(),
+            "markdown": self._get_content(),
         }
 
-    async def _send_request(self) -> str:
+    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(
+        response = self._context.send_request(
             url=self._post_url, data=self._request_data()
         )
 
@@ -186,8 +220,8 @@ class NotebookSyncer:
 
         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()
+    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

ssb_pubmd-0.0.10/src/ssb_pubmd/__init__.py

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

ssb_pubmd-0.0.10/src/ssb_pubmd/__main__.py

@@ -1,13 +0,0 @@
-"""Command-line interface."""
-
-import click
-
-
-@click.command()
-@click.version_option()
-def main() -> None:
-    """SSB Pubmd."""
-
-
-if __name__ == "__main__":
-    main(prog_name="ssb-pubmd")  # pragma: no cover

ssb_pubmd-0.0.10/src/ssb_pubmd/browser_context.py

@@ -1,73 +0,0 @@
-from typing import cast
-
-from playwright.async_api import BrowserContext
-from playwright.async_api import async_playwright
-
-from .notebook_syncer import Response
-
-
-class BrowserRequestContext:
-    """This class is used to create a logged in browser context from which to send requests."""
-
-    def __init__(self) -> None:
-        """Initializes an empty browser context object."""
-        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 login page and waiting for it to be closed by user.
-
-        This function also saves the browser context to a file for later use.
-        """
-        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:
-        """Recreates a browser context object from a 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 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.")
-
-        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