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

ssb_pubmd/__init__.py

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

ssb_pubmd/__main__.py

@@ -1,52 +1,107 @@
 """Command-line interface."""
 
+import json
 import os
+from dataclasses import asdict
+from dataclasses import dataclass
 
 import click
 
-from ssb_pubmd.browser_context import BrowserRequestContext as RequestContext
+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)
 
-@click.group()
-def cli() -> None:
-    """Command-line interface for the ssb_pubmd package."""
-    pass
+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:
-    """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)
+    """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 the content."""
-    post_url = os.getenv("PUBMD_POST_URL", "")
-    request_context = RequestContext()
-    request_context.recreate_from_file()
+    """Sync a markdown or notebook file to the CMS."""
+    config_file = CONFIG_PATH
+    browser_context_file = BROWSER_CONTEXT_PATH
 
-    syncer = MarkdownSyncer(post_url=post_url, request_context=request_context)
-    syncer.content_file_path = content_file_path
+    request_handler = BrowserRequestHandler(browser_context_file)
 
-    content_id = syncer.sync_content()
+    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(content_file_path)}' synced to CMS with content ID: {content_id}"
+        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()  # pragma: no cover
+    cli()

ssb_pubmd/browser_request_handler.py

@@ -0,0 +1,85 @@
+import os
+from collections.abc import Iterator
+from contextlib import contextmanager
+from enum import Enum
+
+from playwright.sync_api import BrowserContext
+from playwright.sync_api import sync_playwright
+
+from .markdown_syncer 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: str, login_url: str = "") -> None:
+        """Initializes an empty browser context object."""
+        self._context_file_path: str = os.path.abspath(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 = None
+
+        response = Response(
+            status_code=api_response.status,
+            body=body,
+        )
+
+        return response

ssb_pubmd/markdown_syncer.py

@@ -18,8 +18,8 @@ class Response:
     body: dict[str, Any] | None = None
 
 
-class RequestContext(Protocol):
-    """Interface for the context in which a request is sent.
+class RequestHandler(Protocol):
+    """Interface for the handling how the request is sent.
 
     Implementing classes may handle authentication, sessions, etc.
     """
@@ -34,11 +34,11 @@ class RequestContext(Protocol):
         ...
 
 
-class BasicRequestContext:
-    """Basic, unauthenticated request context."""
+class BasicRequestHandler:
+    """Basic, unauthenticated request handler."""
 
     def __init__(self) -> None:
-        """Initializes the basic request context."""
+        """Initializes the basic request handler."""
         pass
 
     def send_request(
@@ -91,10 +91,10 @@ class MarkdownSyncer:
 
     ID_KEY = "_id"
 
-    def __init__(self, post_url: str, request_context: RequestContext) -> None:
+    def __init__(self, post_url: str, request_handler: RequestHandler) -> None:
         """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._request_handler: RequestHandler = request_handler
         self._content_file_path: str = ""
         self._content_file_type: FileType = FileType.MARKDOWN
 
@@ -132,7 +132,7 @@ class MarkdownSyncer:
     @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] + ".json"
+        return os.path.splitext(self.content_file_path)[0] + "-PUBMD.json"
 
     @property
     def display_name(self) -> str:
@@ -197,7 +197,7 @@ class MarkdownSyncer:
 
     def _send_request(self) -> str:
         """Sends the request to the CMS endpoint and returns the content id from the response."""
-        response = self._context.send_request(
+        response = self._request_handler.send_request(
             url=self._post_url, data=self._request_data()
         )
 

{ssb_pubmd-0.0.12.dist-info → ssb_pubmd-0.0.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.12
+Version: 0.0.14
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -51,47 +51,29 @@ Description-Content-Type: text/markdown
 [black]: https://github.com/psf/black
 [poetry]: https://python-poetry.org/
 
-## Features
-
-- Supports logging in through a popup browser window.
-
-## Requirements
-
-- 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
 
-You can install _SSB Pubmd_ via [pip] from [PyPI]:
+Installation with pip:
 
 ```console
 pip install ssb-pubmd
 ```
 
-## Usage
-
-First set environment variables:
+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):
 
 ```console
-export PUBMD_LOGIN_URL=<https://www.example.com/login>
-export PUBMD_POST_URL=<https://www.example.com/post>
+playwright install --with-deps chromium
 ```
 
-To log in, run:
-
-```console
-pubmd login
-```
-
-Close the popup browser window when you are logged in.
+## Usage
 
-To synchronize markdown content to the CMS server, run:
+Run the main command in a terminal to see available subcommands with documentation:
 
 ```console
-pubmd sync <file>
+pubmd
 ```
 
-`<file>` should be an absolute or relative path, and the allowed extensions are `.ipynb` and `md`.
-
 ## Contributing
 
 Contributions are very welcome.

ssb_pubmd-0.0.14.dist-info/RECORD

@@ -0,0 +1,10 @@
+ssb_pubmd/__init__.py,sha256=hWhlVS_FDH9yq7fBdXwggg5opjZwf7gIKY6ZyJ81Y4w,176
+ssb_pubmd/__main__.py,sha256=0Fo6rSeca4uQegIqD5At7I-3smeDwSoM4uG0YvWjK3U,2970
+ssb_pubmd/browser_request_handler.py,sha256=mxUQD2_5pd3wy4z5im4XvdzRCknFjGDNEulflXWWWNs,2900
+ssb_pubmd/markdown_syncer.py,sha256=LjwNap3OktkOqt8q-U1tBq2Q79Omygul2-qOBXSYaZQ,7651
+ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ssb_pubmd-0.0.14.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
+ssb_pubmd-0.0.14.dist-info/METADATA,sha256=y_vWYiUtKeVEr7yHV_4D6pVi3hDJ5SPKKuRFgbJzzkI,4139
+ssb_pubmd-0.0.14.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+ssb_pubmd-0.0.14.dist-info/entry_points.txt,sha256=1_NfsiOfqTg948JWXYPwi4QtDk90KHkNn1CQtye8rJ0,48
+ssb_pubmd-0.0.14.dist-info/RECORD,,

ssb_pubmd/browser_context.py

@@ -1,71 +0,0 @@
-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.12.dist-info/RECORD

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