ssb-pubmd 0.0.19__py3-none-any.whl → 0.1.1__py3-none-any.whl

ssb_pubmd/markdown_syncer.py

@@ -1,183 +0,0 @@
-import json
-from pathlib import Path
-
-import nbformat
-from nbformat import NotebookNode
-
-from ssb_pubmd.constants import METADATA_FILE
-from ssb_pubmd.constants import ContentType
-from ssb_pubmd.request_handler import RequestHandler
-from ssb_pubmd.request_handler import Response
-
-
-class MarkdownSyncer:
-    """This class syncs a content file 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 markdown/notebook file).
-    -   On subsequent requests, the stored value is sent as *_id*.
-    """
-
-    ID_KEY = "_id"
-
-    def __init__(
-        self,
-        post_url: str,
-        request_handler: RequestHandler,
-        metadata_file: Path = METADATA_FILE,
-    ) -> None:
-        """Creates a markdown syncer instance that connects to the CMS through the post url."""
-        self._post_url: str = post_url
-        self._request_handler: RequestHandler = request_handler
-        self._content_file_path: Path = Path()
-        self._content_file_type: ContentType = ContentType.MARKDOWN
-        self._metadata_file_path: Path = metadata_file
-
-    @property
-    def content_file_path(self) -> Path:
-        """Returns the path of the content file."""
-        return self._content_file_path
-
-    @content_file_path.setter
-    def content_file_path(self, path: Path) -> None:
-        """Sets the path of the content file."""
-        if not path.is_file():
-            raise FileNotFoundError(f"The file {path} does not exist.")
-
-        ext = path.suffix.lower()
-        for t in ContentType:
-            if ext == t.value:
-                self._content_file_type = t
-                break
-        else:
-            allowed_extensions = [t.value for t in ContentType]
-            sep = ", "
-            raise ValueError(
-                f"The file {path} has extension {ext}, but should be one of: {sep.join(allowed_extensions)}."
-            )
-
-        self._content_file_path = path
-
-    @property
-    def basename(self) -> str:
-        """The name of the content file without extension."""
-        return self._content_file_path.stem
-
-    @property
-    def display_name(self) -> str:
-        """Generate a display name for the content."""
-        return self.basename.replace("_", " ").title()
-
-    @property
-    def metadata_file_path(self) -> Path:
-        """The path of the metadata file."""
-        return self._metadata_file_path
-
-    @property
-    def metadata_key(self) -> str:
-        """The key that the content metadata will be stored under in the metadata file."""
-        return str(self._content_file_path.absolute())
-
-    def _save_content_id(self, content_id: str) -> None:
-        """Saves the content id to the metadata file."""
-        with open(self._metadata_file_path) as f:
-            try:
-                data = json.load(f)
-            except json.JSONDecodeError:
-                data = {}
-
-        data[self.metadata_key] = {
-            self.ID_KEY: content_id,
-        }
-
-        with open(self._metadata_file_path, "w") as f:
-            json.dump(data, f, indent=4)
-
-    def _get_content_id(self) -> str:
-        """Fetches the content id from the metadata file if it exists, otherwise an empty string."""
-        with open(self._metadata_file_path) as f:
-            try:
-                data = json.load(f)
-            except json.JSONDecodeError:
-                data = {}
-
-        metadata: dict[str, str] = data.get(self.metadata_key, {})
-
-        content_id = metadata.get(self.ID_KEY, "")
-
-        return content_id
-
-    def _read_notebook(self) -> NotebookNode:
-        """Reads the notebook file and returns its content."""
-        return nbformat.read(self._content_file_path, as_version=nbformat.NO_CONVERT)  # type: ignore
-
-    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()
-
-        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 _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 ContentType.MARKDOWN:
-                content = self._get_content_from_markdown_file()
-            case ContentType.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(),
-        }
-
-    def sync_content(self) -> Response:
-        """Sends the request to the CMS endpoint and returns the content id from the response."""
-        response = self._request_handler.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
-        self._save_content_id(content_id)
-
-        return response

ssb_pubmd/request_handler.py

@@ -1,56 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-from typing import Protocol
-
-import requests
-
-
-@dataclass
-class Response:
-    """The response object used in the package."""
-
-    status_code: int
-    body: dict[str, Any]
-
-
-class RequestHandler(Protocol):
-    """Interface for handling how a request are sent.
-
-    Implementing classes may handle authentication, sessions, etc.
-    """
-
-    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 BasicRequestHandler:
-    """Basic, unauthenticated request handler."""
-
-    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 = {}
-
-        return Response(
-            status_code=response.status_code,
-            body=body,
-        )

ssb_pubmd-0.0.19.dist-info/RECORD

@@ -1,13 +0,0 @@
-ssb_pubmd/__init__.py,sha256=hWhlVS_FDH9yq7fBdXwggg5opjZwf7gIKY6ZyJ81Y4w,176
-ssb_pubmd/__main__.py,sha256=iIjz73oLP323XyF9cB4LAvO8C47oFhIGDztuzJTOjYo,5089
-ssb_pubmd/browser_request_handler.py,sha256=rfTzsXpKNikH7HchzGkoV09O5bsxmpCB-JGzJ-_lyBc,2902
-ssb_pubmd/constants.py,sha256=0Fh9dOX0wN9spON96Zk8UIhh2yCmTgJVZd2W2uYdXqk,565
-ssb_pubmd/jwt_request_handler.py,sha256=Q3Da2R3tJwh1w40bESm90-JZwXfeYvu6R3K6cQ4-ySM,2844
-ssb_pubmd/markdown_syncer.py,sha256=2MCUlVofXDfUpNCoxz4byfVwc9n_eNABcaOfgxKvMy4,6535
-ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ssb_pubmd/request_handler.py,sha256=yjQaIXi3sRoyt9I4MOjfOXvco_VHPWB6OAMRapCH1GY,1318
-ssb_pubmd-0.0.19.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
-ssb_pubmd-0.0.19.dist-info/METADATA,sha256=m4JJpfLDtetdNIFxJz_BhII5ZK23FsgiVKTLBsa5Id8,4331
-ssb_pubmd-0.0.19.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-ssb_pubmd-0.0.19.dist-info/entry_points.txt,sha256=1_NfsiOfqTg948JWXYPwi4QtDk90KHkNn1CQtye8rJ0,48
-ssb_pubmd-0.0.19.dist-info/RECORD,,

ssb_pubmd-0.0.19.dist-info/entry_points.txt

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