ssb-pubmd 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

ssb_pubmd/__init__.py

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

ssb_pubmd/__main__.py

@@ -1,13 +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()
-@click.version_option()
-def main() -> None:
-    """SSB Pubmd."""
+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__":
-    main(prog_name="ssb-pubmd")  # pragma: no cover
+    cli()  # pragma: no cover

ssb_pubmd/browser_context.py

@@ -1,9 +1,10 @@
-from typing import cast
+from playwright.sync_api import BrowserContext
+from playwright.sync_api import StorageState
+from playwright.sync_api import sync_playwright
 
-from playwright.async_api import BrowserContext
-from playwright.async_api import async_playwright
+from .markdown_syncer import Response
 
-from .notebook_syncer import Response
+BROWSER_CONTEXT_FILE = "browser_context.json"
 
 
 class BrowserRequestContext:
@@ -11,39 +12,37 @@ class BrowserRequestContext:
 
     def __init__(self) -> None:
         """Initializes an empty browser context object."""
-        self._storage_state_path: str = "browser_context.json"
+        self._storage_state_path: str = BROWSER_CONTEXT_FILE
         self._context: BrowserContext | None = None
 
-    async def create_new(self, login_url: str) -> BrowserContext:
+    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 = await async_playwright().start()
-        browser = await playwright.chromium.launch(headless=False)
+        playwright = sync_playwright().start()
+        browser = playwright.chromium.launch(headless=False)
 
-        self._context = await browser.new_context()
-        login_page = await self._context.new_page()
+        self._context = browser.new_context()
+        login_page = self._context.new_page()
 
-        await login_page.goto(login_url)
-        await login_page.wait_for_event("close", timeout=0)
+        login_page.goto(login_url)
+        login_page.wait_for_event("close", timeout=0)
 
-        await self._context.storage_state(path=self._storage_state_path)
+        storage_state = self._context.storage_state(path=self._storage_state_path)
 
-        return self._context
+        return self._storage_state_path, storage_state
 
-    async def recreate_from_file(self) -> BrowserContext:
+    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)
+        playwright = sync_playwright().start()
+        browser = playwright.chromium.launch(headless=False)
 
-        self._context = await browser.new_context(
-            storage_state=self._storage_state_path
-        )
+        self._context = browser.new_context(storage_state=self._storage_state_path)
 
         return self._context
 
-    async def send_request(
+    def send_request(
         self,
         url: str,
         headers: dict[str, str] | None = None,
@@ -53,14 +52,13 @@ class BrowserRequestContext:
         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(
+        api_response = self._context.request.post(
             url,
-            params=params,
+            params=data,
         )
 
         try:
-            body = await api_response.json()
+            body = api_response.json()
             body = dict(body)
         except Exception:
             body = None

ssb_pubmd/{notebook_syncer.py → 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.dist-info → ssb_pubmd-0.0.12.dist-info}/METADATA

@@ -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.12.dist-info/RECORD

@@ -0,0 +1,10 @@
+ssb_pubmd/__init__.py,sha256=WD-U43QQTQIRSRgTHSnEjcG5MuH4T_CPFHPXols2NLk,179
+ssb_pubmd/__main__.py,sha256=WdiICEorWrTbM1NDIkG-97Gg49IV5Pm_MBkQHr3Scec,1364
+ssb_pubmd/browser_context.py,sha256=JXDlvUJZ-NYLQlE0_MRAiuRxGrMVBfvm5Rt2QX7dYRA,2344
+ssb_pubmd/markdown_syncer.py,sha256=RHP3bHIGPRLichrleygOS2WIVN1KOlYPehbrcenJMRk,7631
+ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ssb_pubmd-0.0.12.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
+ssb_pubmd-0.0.12.dist-info/METADATA,sha256=6YfXG5dXzW-2xU-Cdbtik5-ophdBRngUsSbBJ_DVYkw,4707
+ssb_pubmd-0.0.12.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+ssb_pubmd-0.0.12.dist-info/entry_points.txt,sha256=1_NfsiOfqTg948JWXYPwi4QtDk90KHkNn1CQtye8rJ0,48
+ssb_pubmd-0.0.12.dist-info/RECORD,,

{ssb_pubmd-0.0.10.dist-info → ssb_pubmd-0.0.12.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any

ssb_pubmd-0.0.12.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pubmd=ssb_pubmd.__main__:cli
+

ssb_pubmd-0.0.10.dist-info/RECORD

@@ -1,10 +0,0 @@
-ssb_pubmd/__init__.py,sha256=bEVVJ-sm5MmH5bXnzzyek_nSAvutyB0WNpBy835lE2g,179
-ssb_pubmd/__main__.py,sha256=8D0yedPhnV_2L7nj0s0KUKxNQqPxoussMHGDNM-vyjg,209
-ssb_pubmd/browser_context.py,sha256=ihFYos4Vm-0Llgr5WlFRAITlE6CAY1D53baMF5rzxwI,2405
-ssb_pubmd/notebook_syncer.py,sha256=cyfB7jsXUVIaohVt38x8TKxlllkk1txy5jVab8vclSc,6511
-ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ssb_pubmd-0.0.10.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
-ssb_pubmd-0.0.10.dist-info/METADATA,sha256=Ylp5hVFos3KaDjGpbJBgngtmB6lsLugntRTaRvIDDAo,4407
-ssb_pubmd-0.0.10.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-ssb_pubmd-0.0.10.dist-info/entry_points.txt,sha256=o4oU99zbZNIBKGYWdgdEG6ev-62ZRWEJOe7EOjJaajk,53
-ssb_pubmd-0.0.10.dist-info/RECORD,,

ssb_pubmd-0.0.10.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-ssb-pubmd=ssb_pubmd.__main__:main
-