ssb-pubmd 0.0.6__tar.gz → 0.0.7__tar.gz

{ssb_pubmd-0.0.6 → ssb_pubmd-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.6
+Version: 0.0.7
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk

{ssb_pubmd-0.0.6 → ssb_pubmd-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-pubmd"
-version = "0.0.6"
+version = "0.0.7"
 description = "SSB Pubmd"
 authors = ["Olav Landsverk <stud-oll@ssb.no>"]
 license = "MIT"
@@ -38,6 +38,7 @@ sphinx-click = ">=3.0.2"
 typeguard = ">=2.13.3"
 xdoctest = { extras = ["colors"], version = ">=0.15.10" }
 myst-parser = { version = ">=0.16.1" }
+uuid = "^1.30"
 
 [tool.pytest.ini_options]
 pythonpath = ["src"]

{ssb_pubmd-0.0.6 → ssb_pubmd-0.0.7}/src/ssb_pubmd/__init__.py

@@ -1,5 +1,5 @@
 """SSB Pubmd."""
 
-from .functions import notebook_to_cms
+from .exporter import notebook_to_cms
 
 __all__ = ["notebook_to_cms"]

ssb_pubmd-0.0.7/src/ssb_pubmd/exporter.py

@@ -0,0 +1,130 @@
+import json
+import os
+
+import nbformat
+import requests
+from nbformat import NotebookNode
+
+
+class _Exporter:
+    """Helper class for exporting markdown-based content."""
+
+    def __init__(self, endpoint: str) -> None:
+        self.endpoint: str = endpoint
+        self.notebook_folder: str = ""
+        self.notebook_filename: str = ""
+        self.content_id: str = ""
+
+    def _set_working_directory(self) -> None:
+        """Set the working directory to the notebook folder."""
+        if self.notebook_folder:
+            os.chdir(self.notebook_folder)
+        else:
+            os.chdir(os.getcwd())
+
+    def _get_basename(self) -> str:
+        """Returns the name of the notebook file without extension."""
+        return os.path.splitext(self.notebook_filename)[0]
+
+    def _get_display_name(self) -> str:
+        """Generate a display name to send to the CMS endpoint."""
+        return self._get_basename().replace("_", " ").title()
+
+    def _get_data_filename(self) -> str:
+        """Returns the data filename to store the content id returned from the CMS."""
+        return self._get_basename() + ".json"
+
+    def _get_content_id(self) -> str:
+        """Get the content id from the JSON file if it exists."""
+        content_id = ""
+        data_filename = self._get_data_filename()
+        if os.path.exists(data_filename):
+            with open(data_filename) as file:
+                content_id = json.load(file)["_id"]
+        return content_id
+
+    def _read_notebook(self) -> NotebookNode:
+        """Reads the notebook file and returns its content."""
+        return nbformat.read(self.notebook_filename, as_version=nbformat.NO_CONVERT)  # type: ignore
+
+    def _get_content_from_notebook(self) -> str:
+        """Extracts all markdown cells from the notebook and returns it as a merged string."""
+        notebook = self._read_notebook()
+        markdown_content = ""
+        for cell in notebook.cells:
+            if cell.cell_type == "markdown":
+                markdown_content += cell.source + "\n\n"
+        return markdown_content
+
+    def _prepare_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._get_display_name(),
+            "markdown": self._get_content_from_notebook(),
+        }
+
+    def _prepare_headers(self) -> dict[str, str]:
+        """Prepares the headers for the request."""
+        return {"Content-Type": "application/json"}
+
+    def _send_request(self) -> None:
+        """Sends the request to the CMS endpoint and returns the content id."""
+        data = self._prepare_request_data()
+        response = requests.post(
+            self.endpoint,
+            data=json.dumps(data),
+            headers=self._prepare_headers(),
+        )
+        self.content_id = response.json()["_id"]
+
+    def _save_content_id(self) -> None:
+        """Saves the content id to a JSON file."""
+        with open(self._get_data_filename(), "w") as file:
+            json.dump({"_id": self.content_id}, file)
+
+    def set_notebook(self, notebook_filename: str, notebook_folder: str) -> None:
+        """Uses the notebook_filename and working directory."""
+        self.notebook_filename = notebook_filename
+        self.notebook_folder = notebook_folder
+        self._set_working_directory()
+
+    def export(self) -> str:
+        """Main method to export the notebook content to the CMS endpoint."""
+        self._send_request()
+        self._save_content_id()
+        return self.content_id
+
+
+def notebook_to_cms(
+    notebook_filename: str,
+    endpoint: str,
+    notebook_folder: str = "",
+) -> str:
+    r"""Sends all the markdown content of a notebook to a CMS endpoint.
+
+    The CMS endpoint must satisfy two 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 notebook file).
+    -   On subsequent requests, the stored value is sent as *id*.
+
+    Args:
+        notebook_filename (str): The name of the notebook file, e.g. `"my_notebook.ipynb"`.
+        endpoint (str): The URL of the CMS endpoint.
+        notebook_folder (str): Sets a custom notebook folder (as absolute path) containing the notebook file.
+            If not set, the current folder is used.
+
+    Returns:
+        str: The identifier of the content returned by the CMS endpoint.
+    """
+    exporter = _Exporter(endpoint)
+    exporter.set_notebook(notebook_filename, notebook_folder)
+    return exporter.export()

ssb_pubmd-0.0.6/src/ssb_pubmd/functions.py

@@ -1,85 +0,0 @@
-"""A collection of useful functions.
-
-The template and this example uses Google style docstrings as described at:
-https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html
-
-"""
-
-import json
-import os
-
-import nbformat
-import requests
-from nbformat import NotebookNode
-
-
-def _read_notebook(fp: str) -> NotebookNode:
-    return nbformat.read(fp, as_version=nbformat.NO_CONVERT)  # type: ignore
-
-
-def notebook_to_cms(
-    notebook_filename: str,
-    endpoint: str,
-    notebook_folder: str = "",
-    display_name: str = "",
-) -> str:
-    r"""Sends all the markdown content of a notebook to a CMS endpoint.
-
-    The CMS endpoint must satisfy two 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 notebook file).
-    -   On subsequent requests, the stored value is sent as *id*.
-
-    Args:
-        notebook_filename (str): The name of the notebook file, e.g. `"my_notebook.ipynb"`.
-        endpoint (str): The URL of the CMS endpoint.
-        notebook_folder (str): Sets a custom notebook folder (as absolute path) containing the notebook file.
-            If not set, the current folder is used.
-        display_name (str): Send a custom *displayName* value to the CMS endpoint.
-            If not set, the notebook filename is used (with the file extension removed,
-            underscores replaced with spaces, and words capitalized).
-
-    Returns:
-        str: The body of the response from the CMS endpoint, string-formatted.
-    """
-    if notebook_folder:
-        os.chdir(notebook_folder)
-    else:
-        os.chdir(os.getcwd())
-
-    basename = os.path.splitext(notebook_filename)[0]
-    json_filename = basename + ".json"
-
-    _id = ""
-    if os.path.exists(json_filename):
-        with open(json_filename) as file:
-            _id = json.load(file)["_id"]
-
-    if not display_name:
-        display_name = basename.replace("_", " ").title()
-
-    markdown = ""
-    if os.path.exists(notebook_filename):
-        notebook = _read_notebook(notebook_filename)
-        markdown = "\n\n".join(
-            cell.source for cell in notebook.cells if cell.cell_type == "markdown"
-        )
-
-    request_data = {"_id": _id, "displayName": display_name, "markdown": markdown}
-    response = requests.post(endpoint, data=request_data)
-
-    body = response.json()
-    node_id = body.get("_id")
-
-    with open(json_filename, "w") as file:
-        json.dump({"_id": node_id}, file)
-
-    return json.dumps(body, indent=4)