ssb-pubmd 0.0.13__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,87 +1,102 @@
 """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
 
-CONFIG_FILE = "pubmd_config.json"
+BASE_DIR = os.path.join(os.path.expanduser("~"), ".pubmd")
+os.makedirs(BASE_DIR, exist_ok=True)
 
+CONFIG_PATH = os.path.join(BASE_DIR, "config.json")
+BROWSER_CONTEXT_PATH = os.path.join(BASE_DIR, "browser_context.json")
 
-class ConfigKeys:
-    """The keys used in the configuration file."""
 
-    LOGIN = "login_url"
-    POST = "post_url"
+@dataclass
+class Config:
+    """Handles the user configuration."""
 
+    login_url: str = ""
+    post_url: str = ""
 
-def get_config_value(key: str) -> str:
-    """Get a configuration value."""
-    try:
-        with open(CONFIG_FILE) as json_file:
-            config = json.load(json_file)
-            value = config[key]
-    except FileNotFoundError:
-        click.echo(
-            f"Configuration file '{CONFIG_FILE}' not found. Please run the 'config' command first."
-        )
-    except Exception:
-        click.echo(
-            f"Error reading configuration file '{CONFIG_FILE}'. Please run the 'pubmd config' command again."
-        )
-    return str(value)
+    @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)
 
-
-@click.group()
-def cli() -> None:
-    """'pubmd' is a tool to sync markdown and notebook files to a CMS application.
-
-    Setup with subcommands 'config' and 'login', then use subcommand 'sync'.
-    """
-    pass
+    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:
-    """Configure the CMS to connect to."""
+    """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 = {ConfigKeys.LOGIN: login_url, ConfigKeys.POST: post_url}
+    config = Config(login_url=login_url, post_url=post_url)
 
-    with open(CONFIG_FILE, "w") as json_file:
-        json.dump(config, json_file, indent=4)
+    config.save(config_file)
 
-    click.echo(f"\nThe configuration has been stored in:\n{CONFIG_FILE}")
+    click.echo(f"\nConfiguration stored in:\n{config_file}")
 
 
 @click.command()
 def login() -> None:
-    """Login to the CMS application."""
-    login_url = get_config_value(ConfigKeys.LOGIN)
-    request_context = RequestContext()
-    storage_state_file, storage_state = request_context.create_new(login_url)
-    click.echo(f"\nThe browser context has been stored in:\n{storage_state_file}")
+    """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 a markdown or notebook file to the CMS."""
-    post_url = get_config_value(ConfigKeys.POST)
-    request_context = RequestContext()
-    request_context.recreate_from_file()
+    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)
@@ -89,4 +104,4 @@ 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.13.dist-info → ssb_pubmd-0.0.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.13
+Version: 0.0.14
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -51,10 +51,6 @@ 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.
-
 
 ## Installation
 
@@ -67,7 +63,7 @@ pip install ssb-pubmd
 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
-playwright install --with-deps chromium`
+playwright install --with-deps chromium
 ```
 
 ## Usage

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 = "pubmd_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.13.dist-info/RECORD

@@ -1,10 +0,0 @@
-ssb_pubmd/__init__.py,sha256=WD-U43QQTQIRSRgTHSnEjcG5MuH4T_CPFHPXols2NLk,179
-ssb_pubmd/__main__.py,sha256=a99fscfnw6rr2fOG4KFsCzZnSzo2eo94xpX7vyLImV8,2611
-ssb_pubmd/browser_context.py,sha256=zNT-YehZh00uG8f4KGr3KbXIFOE84_7Ky4HjOmxN4zs,2350
-ssb_pubmd/markdown_syncer.py,sha256=RHP3bHIGPRLichrleygOS2WIVN1KOlYPehbrcenJMRk,7631
-ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ssb_pubmd-0.0.13.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
-ssb_pubmd-0.0.13.dist-info/METADATA,sha256=P05Hv5mkPm8z0dF63GMhfE7PZdUr4u8uWylv-WvvXWU,4208
-ssb_pubmd-0.0.13.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-ssb_pubmd-0.0.13.dist-info/entry_points.txt,sha256=1_NfsiOfqTg948JWXYPwi4QtDk90KHkNn1CQtye8rJ0,48
-ssb_pubmd-0.0.13.dist-info/RECORD,,