ssb-pubmd 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

ssb_pubmd/domain/document_publisher.py

@@ -0,0 +1,46 @@
+from ssb_pubmd.adapters.content_parser import ContentParser
+from ssb_pubmd.adapters.document_processor import DocumentProcessor
+from ssb_pubmd.adapters.publish_client import PublishClient
+from ssb_pubmd.adapters.storage import Storage
+
+USER_KEY_PREFIX = "user:"
+DOCUMENT_KEY = "app:document"
+
+def sync_document(
+    raw_document_content: str,
+    document_processor: DocumentProcessor,
+    content_parser: ContentParser,
+    storage: Storage,
+    publish_client: PublishClient,
+) -> str:
+    document_processor.load(raw_document_content)
+
+    document_metadata = document_processor.extract_metadata(target_key="ssb")
+    document_metadata["content_type"] = "article"
+
+    document_publish_path = storage.get(DOCUMENT_KEY).get("publish_path")
+    if not document_publish_path:
+        content = content_parser.parse(metadata=document_metadata, html=None)
+        response = publish_client.send_content(content)
+        storage.update(
+            DOCUMENT_KEY,
+            {"publish_id": response.publish_id, "publish_path": response.publish_path},
+        )
+        document_publish_path = response.publish_path
+
+    document_elements = document_processor.extract_elements(target_class="ssb")
+    for id_, html in document_elements:
+        key = USER_KEY_PREFIX + id_
+        metadata = storage.get(key) | {"publish_folder": document_publish_path}
+        component = content_parser.parse(metadata, html)
+        response = publish_client.send_content(component)
+        storage.update(key, {"publish_id": response.publish_id})
+        document_processor.replace_element(id_, response.publish_html)
+
+    article_metadata = document_metadata | {
+        "publish_id": storage.get(DOCUMENT_KEY).get("publish_id")
+    }
+    html = document_processor.extract_html()
+    article = content_parser.parse(metadata=article_metadata, html=html)
+    response = publish_client.send_content(article)
+    return response.publish_url

ssb_pubmd/notebook_client.py

@@ -0,0 +1,133 @@
+from pathlib import Path
+from typing import Literal
+
+import narwhals as nw
+from narwhals.typing import IntoDataFrame
+
+from ssb_pubmd.adapters.content_parser import Content
+from ssb_pubmd.adapters.content_parser import ContentParser
+from ssb_pubmd.adapters.content_parser import MimirContentParser
+from ssb_pubmd.adapters.storage import LocalFileStorage
+from ssb_pubmd.adapters.storage import Storage
+from ssb_pubmd.domain.document_publisher import USER_KEY_PREFIX
+
+STORAGE: Storage = LocalFileStorage(project_folder=Path.cwd())
+CONTENT_PARSER: ContentParser = MimirContentParser()
+
+class NotebookClientError(Exception): ...
+
+def configure_factbox(
+    key: str,
+    title: str,
+    display_type: Literal["default", "sneakPeek", "aiIcon"] = "default",
+) -> None:
+    """Oppretter en faktaboks og printer en Markdown-snippet som kan limes inn i artikkelen (på en ny linje).
+
+    :param key: En unik nøkkel for innholdet.
+    :param title: Tittelen til faktaboksen.
+    :param display_type: Visning av faktaboksen.
+
+        Alternativer:
+
+        * "default": Bare tittel (standard)
+        * "sneakPeek": Tittel og litt av forklaringsteksten
+        * "aiIcon": Tittel og litt av forklaringsteksten + KI-ikon
+    """
+    metadata = {
+        "content_type": "factBox",
+        "title": title,
+        "display_type": display_type,
+    }
+
+    content = CONTENT_PARSER.parse(
+        metadata=metadata,
+        html=None,
+    )
+    _store_user_content(user_key=key, content=content)
+
+    md = _get_markdown_snippet(
+        key,
+        placeholder_text="Faktaboksens tekst skrives her med Markdown-syntaks.\n\n### Underoverskrift\n\nNy paragraf.",
+    )
+    print(md)
+
+
+def create_highchart(
+    key: str,
+    title: str,
+    dataframe: IntoDataFrame | None = None,
+    tbml: str | None = None,
+    graph_type: Literal["line", "pie", "column", "bar", "area", "barNegative"] = "line",
+    xlabel: str = "x",
+    ylabel: str = "y"
+) -> None:
+    """Oppretter et highchart og printer en Markdown-snippet som kan limes inn i artikkelen (på en ny linje).
+
+    Som datakilde er det nødvendig å spesifisere enten `dataframe` eller `tbml`.
+
+    :param key: En unik nøkkel for innholdet.
+    :param title: Tittelen til highchartet.
+    :param dataframe: En pandas, Polars eller PyArrow dataframe.
+    :param tbml: URL eller TBML-id.
+    :param graph_type: Graftype.
+
+        Alternativer:
+
+        * "line": Linje (standard)
+        * "pie": Kake
+        * "column": Stolpe
+        * "bar": Liggende stolpe
+        * "area": Areal
+        * "barNegative": Pyramide
+
+    :param xlabel: X-akse, tittel.
+    :param ylabel: Y-akse, tittel.
+    """
+    if dataframe is None and tbml is None:
+        raise NotebookClientError("Either 'dataframe' or 'tbml' must be specified.")
+    metadata = {
+        "content_type": "highchart",
+        "title": title,
+        "graph_type": graph_type,
+        "xlabel": xlabel,
+        "ylabel": ylabel
+    }
+    if tbml is not None:
+        metadata["tbml"] = tbml
+    html = _dataframe_to_html_table(dataframe) if dataframe is not None else None
+    content = CONTENT_PARSER.parse(metadata, html)
+    _store_user_content(user_key=key, content=content)
+
+    md = _get_markdown_snippet(key)
+    print(md)
+
+
+def _store_user_content(user_key: str, content: Content) -> None:
+    key = USER_KEY_PREFIX + str(user_key)
+    STORAGE.update(key, content.to_dict())
+
+
+def _dataframe_to_html_table(dataframe: IntoDataFrame) -> str:
+    df = nw.from_native(dataframe)
+    html = "<table><tbody>\n"
+
+    html += "<tr>\n"
+    for name in df.columns:
+        html += f"    <td>{name}</td>\n"
+    html += "</tr>\n"
+
+    for row in df.iter_rows():
+        html += "  <tr>\n"
+        for value in row:
+            html += f"    <td>{value}</td>\n"
+        html += "  </tr>\n"
+
+    html += "</tbody></table>"
+
+    return html
+
+
+def _get_markdown_snippet(key: str, placeholder_text: str | None = None) -> str:
+    div_config = f"{{ #{key} .ssb }}"
+    div_content = f"\n{placeholder_text}\n\n" if placeholder_text is not None else ""
+    return f"::: {div_config}\n{div_content}:::"

ssb_pubmd/templates/template.qmd

@@ -0,0 +1,138 @@
+---
+ssb: 
+  path: /utdanning/grunnskoler/statistikk/elevar-i-grunnskolen/artikler
+  title: "Hovedtittel for artikkelen"
+  authors:
+      - name: Fornavn Etternavn
+        email: ---@ssb.no
+      - name: Fornavn Etternavn
+        email: ---@ssb.no
+  ingress: |
+      Ingress for artikkelen,
+      som kan skrives over flere linjer.
+---
+Dette er en SSB-artikkel skrevet med Quarto Markdown. 
+
+Neste steg:
+
+1. Sjekk at du er logget inn i CMS-et: {{ cms_admin_url }}/tool/com.enonic.app.contentstudio/main.
+
+2. Det er gitt et eksempel på CMS-mappe i feltet `path` ovenfor. Endre denne til CMS-mappen du ønsker å opprette artikkelen i. Dette må være en mappe du har skrivetilgang til.
+
+3. Kjør kommandoen `poetry run ssb-pubmd preview {{ filepath }}`. 
+   
+   * Dette vil opprette en draft-artikkel og printe URL'en til en forhåndsvisning av artikkelen. 
+   * Kommandoen fungerer tilsvarende som `quarto preview`, det vil si at forhåndsvisningen holdes oppdatert etter hvert som du endrer og lagrer denne filen.****
+   * Du må oppdatere nettleservinduet for å se endringene.
+  
+4. Les seksjonene nedenfor for en kort introduksjon til skriving av SSB-artikler i Quarto Markdown.
+
+## Artikkelmetadata
+
+Metadata-blokken øverst viser all metadata som kan settes for en artikkel.
+Dette er noe begrenset i testversjonen, men vil senere være komplett.
+Merk at `path` og `title` er obligatoriske felt.
+
+
+## Markdown
+
+Se [Quarto-referansen](https://quarto.org/docs/authoring/markdown-basics.html). Merk at:
+
+* Hovedoverskrift (`#`) støttes ikke, og skal settes i metadatablokken.
+
+## Kode
+
+Se [Quarto-referansen](https://quarto.org/docs/computations/python.html). Merk at: 
+
+* Ingen kodeblokker eller output vil komme med i artikkelen. 
+* [Kode i teksten](https://quarto.org/docs/computations/inline-code.html) støttes. Koden vil evalueres og erstattes med tekst før artikkelen sendes til CMS'et.
+* All kode må kunne kjøres fra topp til bunn.
+
+## SSB-komponenter
+
+I testversjonen tilbys et begrenset utvalg SSB-komponenter.
+Komponentene opprettes med Python og settes inn med Markdown.
+
+### Opprette komponenter
+
+Importér Python-pakken:
+
+```{python}
+import ssb_pubmd as ssb
+```
+
+Kodeblokkene nedenfor viser opprettelse av to komponenter; et highchart og en faktaboks:
+```{python}
+import pandas as pd
+data = {
+    "År": [
+        2000, 2001, 2002, 2003, 2004,
+        2005, 2006, 2007, 2008, 2009,
+        2010, 2011, 2012, 2013, 2014,
+        2015, 2016, 2017, 2018, 2019
+    ],
+    "Andel": [
+        4, 3.3, 4.7, 5.6, 7.2,
+        6.7, 7, 7.3, 7.6, 7.7,
+        7.7, 7.6, 8, 8.6, 9.4,
+        10, 10.3, 10.7, 11.3, 11.7
+    ]
+}
+df = pd.DataFrame(data)
+
+ssb.Highchart(
+    key="my-highchart",
+    title="Highchart title",
+    dataframe=df,
+    graph_type="line",
+    xlabel="my_xlabel",
+    ylabel="my_ylabel"
+)
+```
+
+```{python}
+ssb.Factbox(
+    key = "my-factbox",
+    title = "Factbox title",
+    display_type = "default")
+```
+
+Dokumentasjon: (link kommer).
+  * For å se alle funksjonene som tilbys, skriv `ssb.` på en kodelinje og tast `Ctrl + Space` (VSCode) eller `Tab` (Jupyterlab).
+  * VSCode: Dokumentasjonen til funksjonen vises automatisk i en popup-boks når man hovrer over funksjonen.
+
+### Sette inn komponenter
+
+Når du kjører en av kodeblokkene ovenfor, vil det printes en Markdown-snippet som kan kopieres og limes inn på en ny linje:
+
+::: { #my-highchart .ssb }
+:::
+
+Merk at faktabokser settes inn med innhold:
+
+::: { #my-factbox .ssb }
+
+Faktaboksens tekst skrives her med Markdown-syntaks.
+
+### Underoverskrift
+
+Ny paragraf.
+
+:::
+
+
+## Synkronisering
+
+Etter å ha synkronisert denne filen til CMS'et, vil du se en ekstra fil i Dapla-tjenesten:
+
+```
+{{ project_folder }}/
+├── {{ filename }}
+├── .ssbno.json
+```
+
+Metadatafilen `.ssbno.json` er automatisk generert og inneholder metadata for den tilhørende CMS-artikkelen. Merk at:
+
+* Dersom `.ssbno.json` slettes, vil en ny CMS-artikkel opprettes ved neste synkronisering.
+* Dersom man jobber med to separate SSB-artikler, skal disse ligge i hver sin mappe, slik at de har hver sin metadatafil.
+

{ssb_pubmd-0.1.0.dist-info → ssb_pubmd-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.1.0
+Version: 0.1.2
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -13,12 +13,15 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: cryptography (>=45.0.5,<46.0.0)
-Requires-Dist: google-cloud-secret-manager (>=2.24.0,<3.0.0)
+Requires-Dist: dapla-auth-client (>=1.2.5,<2.0.0)
+Requires-Dist: ipynbname (>=2025.8.0.0,<2026.0.0.0)
+Requires-Dist: narwhals (>=2.15.0,<3.0.0)
 Requires-Dist: nbformat (>=5.10.4,<6.0.0)
-Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
+Requires-Dist: nh3 (>=0.3.2,<0.4.0)
+Requires-Dist: pandocfilters (>=1.5.1,<2.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
 Requires-Dist: requests (>=2.32.4,<3.0.0)
-Requires-Dist: types-requests (>=2.32.4.20250611,<3.0.0.0)
+Requires-Dist: watchfiles (>=1.1.1,<2.0.0)
 Project-URL: Changelog, https://github.com/statisticsnorway/ssb-pubmd/releases
 Project-URL: Documentation, https://statisticsnorway.github.io/ssb-pubmd
 Project-URL: Homepage, https://github.com/statisticsnorway/ssb-pubmd

ssb_pubmd-0.1.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+ssb_pubmd/__init__.py,sha256=GmZebzEEIJcwwYD6_J5irpY5-lGAKFr8lRrTGB_nAPA,170
+ssb_pubmd/__main__.py,sha256=7Trn-DZkNbVn6s5J8FVg9JFtpFEHv-4VKZ34MVs23Cc,204
+ssb_pubmd/adapters/content_parser.py,sha256=ExOULfwoFBVb9h2wH8m61fWFy192ZEIG2LI3fuFRpbE,5141
+ssb_pubmd/adapters/document_processor.py,sha256=GN4FJmWcyiCdTBzWkyUReFGd7AME-F4Eq5N4JmarddQ,4271
+ssb_pubmd/adapters/publish_client.py,sha256=5JIVtJCV_uLDv6YwGitQLE_T4dLWaWQCm9nO6F9RpR4,3350
+ssb_pubmd/adapters/storage.py,sha256=Dexfgw0csQ9wljC6lqf9kFmoM2CHdfMghm-qBrgdWjM,1227
+ssb_pubmd/cli.py,sha256=fOJKHz8l871k5rS-1b1IUzgnhJozMhiujXwzqyeL6og,3262
+ssb_pubmd/config.py,sha256=FbHkHDobBdqZLT9ZZKfH9Ch0wtj4TmKNF8EMCbQAJgE,844
+ssb_pubmd/domain/document_publisher.py,sha256=hgzJx9kGZJOVLrgFRg-JGAmNsasvHA9_BA1g3htcWrQ,1920
+ssb_pubmd/notebook_client.py,sha256=w4Jlo6CH5tVTzSxZlD0bPn0CPwgdX2NL7nKzlfstheU,4090
+ssb_pubmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ssb_pubmd/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ssb_pubmd/templates/template.qmd,sha256=s4aEMlseEyZMytHrNz8HpcYd1JG2UPwTOL_edJ48qmQ,4084
+ssb_pubmd-0.1.2.dist-info/LICENSE,sha256=tF5bnYv09fgH5ph9t1EpH1MGrVOGTQeswL4dzVeZ_ak,1073
+ssb_pubmd-0.1.2.dist-info/METADATA,sha256=NsDUsihthkrVF4tv7wXzp4e6JTD6gvOx_nbim_w1PLk,4101
+ssb_pubmd-0.1.2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+ssb_pubmd-0.1.2.dist-info/entry_points.txt,sha256=o4oU99zbZNIBKGYWdgdEG6ev-62ZRWEJOe7EOjJaajk,53
+ssb_pubmd-0.1.2.dist-info/RECORD,,

ssb_pubmd/adapters/cli.py

@@ -1,21 +0,0 @@
-import sys
-from dataclasses import dataclass
-
-from ssb_pubmd.ports import CmsManager
-
-
-@dataclass
-class CliAdapter:
-    cms_manager: CmsManager
-
-    def run(self, system_arguments: list[str]) -> None:
-        match system_arguments:
-            case [_, "sync", file_path]:
-                preview = self.cms_manager.sync(file_path)
-                print(f"Preview URL: {preview}")
-                # except Exception as e:
-                #     print(f"Error during sync: {e}")
-                #     sys.exit(1)
-            case _:
-                print("Usage: ssb-pubmd sync <content_file_path>")
-                sys.exit(1)

ssb_pubmd/adapters/cms_client.py

@@ -1,47 +0,0 @@
-from urllib.parse import urlparse
-
-import requests
-
-from ssb_pubmd.models import CmsResponse
-from ssb_pubmd.models import Content
-
-
-class CmsClientError(Exception): ...
-
-
-class MimirCmsClient:
-    base_url: str
-
-    def __init__(self, base_url: str) -> None:
-        self.base_url = base_url
-
-    def _convert_preview_url(self, url_from_response: str) -> str:
-        """Convert the preview URL to a full URL if it's relative."""
-        url = urlparse(url_from_response)
-        if url.scheme and url.netloc:
-            return url.geturl()
-        else:
-            return urlparse(self.base_url)._replace(path=url.path).geturl()
-
-    def send(self, token: str, content: Content) -> CmsResponse:
-        """Sends a request to the Enonic CMS, assumed to have the mimir application installed (currently this only works with the feature branch https://github.com/statisticsnorway/mimir/pull/3192)."""
-        try:
-            response = requests.post(
-                f"{self.base_url}/_/service/mimir/postMarkdown",
-                headers={
-                    "Authorization": f"Bearer {token}",
-                    "Content-Type": "application/json",
-                },
-                json=content.to_json(),
-            )
-            if response.status_code != 200:
-                raise CmsClientError(
-                    f"Request to CMS failed with status code {response.status_code}."
-                )
-            body = response.json()
-            return CmsResponse(
-                id=body["_id"],
-                preview_url=self._convert_preview_url(body["previewPath"]),
-            )
-        except Exception as e:
-            raise CmsClientError("Request to CMS failed.") from e

ssb_pubmd/adapters/local_storage.py

@@ -1,72 +0,0 @@
-import json
-from dataclasses import dataclass
-from pathlib import Path
-
-import nbformat
-
-from ssb_pubmd.models import Content
-
-ID_KEY = "_id"
-
-
-class LocalStorageError(Exception): ...
-
-
-@dataclass
-class LocalStorageAdapter:
-    metadata_file_path: Path
-
-    def get_file_id(self, file_path: Path) -> str:
-        """
-        Returns the content id of a given file path.
-        If no id is registered for the given file path,
-        it returns an empty string.
-        """
-        with open(self.metadata_file_path) as metadata_file:
-            metadata = json.load(metadata_file)
-            return str(metadata.get(str(file_path.absolute()), {}).get(ID_KEY, ""))
-
-    def set_file_id(self, file_path: Path, content_id: str) -> None:
-        """Stores a given file's content id in the metadata file"""
-        with open(self.metadata_file_path) as metadata_file:
-            metadata = json.load(metadata_file)
-        metadata[str(file_path.absolute())] = {ID_KEY: content_id}
-        with open(self.metadata_file_path, "w") as metadata_file:
-            json.dump(metadata, metadata_file)
-
-    def get_content(self, file_path: Path) -> Content:
-        """
-        Returns the markdown content of a given file.
-        If the file is neither a .md or a .ipynb file,
-        this function will throw a `LocalStorageError`
-        """
-        return Content(
-            content_id=self.get_file_id(file_path),
-            file_path=file_path,
-            markdown=self._get_content(file_path),
-        )
-
-    def _get_content_from_notebook_file(self, file_path: Path) -> str:
-        """Extracts all markdown cells from the notebook and returns it as a string."""
-        notebook = nbformat.read(file_path, as_version=nbformat.NO_CONVERT)  # type: ignore
-        markdown_cells = []
-        for cell in notebook.cells:
-            if cell.cell_type == "markdown":
-                markdown_cells.append(cell.source)
-        sep = "\n\n"
-        return sep.join(markdown_cells)
-
-    def _get_content_from_markdown_file(self, file_path: Path) -> str:
-        """Returns the content of a markdown file as a string."""
-        with open(file_path) as file:
-            return file.read()
-
-    def _get_content(self, file_path: Path) -> str:
-        file_type = file_path.suffix
-        match file_type:
-            case ".md":
-                return self._get_content_from_markdown_file(file_path)
-            case ".ipynb":
-                return self._get_content_from_notebook_file(file_path)
-            case _:
-                raise LocalStorageError(f"Unsupported file type: {file_type}")

ssb_pubmd/adapters/secret_manager_client.py

@@ -1,66 +0,0 @@
-"""This module handles HTTP requests and responses to and from the CMS."""
-
-import json
-from dataclasses import dataclass
-from datetime import datetime
-
-import jwt
-from google.cloud import secretmanager
-
-
-@dataclass
-class Secret:
-    private_key: str
-    kid: str
-    principal_key: str
-
-
-class SecretManagerError(Exception): ...
-
-
-class GoogleSecretManagerClient:
-    TYPE = "JWT"
-    ALGORITHM = "RS256"
-    _gc_secret_resource_name: str
-
-    def __init__(self, gc_secret_resource_name: str) -> None:
-        self._gc_secret_resource_name = gc_secret_resource_name
-
-    def _get_secret(self) -> Secret:
-        """Fetches the private key and related data from Google Cloud Secret Manager."""
-        client = secretmanager.SecretManagerServiceClient()
-        response = client.access_secret_version(name=self._gc_secret_resource_name)
-        raw_data = response.payload.data.decode("UTF-8")
-        data = json.loads(raw_data)
-        try:
-            return Secret(
-                private_key=data["privateKey"],
-                kid=data["kid"],
-                principal_key=data["principalKey"],
-            )
-        except KeyError as e:
-            raise SecretManagerError(
-                "The secret must be a JSON object with keys 'privateKey', 'kid' and 'principalKey'."
-            ) from e
-
-    def generate_token(self) -> str:
-        secret = self._get_secret()
-
-        header = {
-            "kid": secret.kid,
-            "typ": self.TYPE,
-            "alg": self.ALGORITHM,
-        }
-
-        iat = int(datetime.now().timestamp())
-        exp = iat + 30
-        payload = {
-            "sub": secret.principal_key,
-            "iat": iat,
-            "exp": exp,
-        }
-
-        token = jwt.encode(
-            payload, secret.private_key, algorithm=self.ALGORITHM, headers=header
-        )
-        return token

ssb_pubmd/enonic_cms_manager.py

@@ -1,30 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-from ssb_pubmd.config import Config
-from ssb_pubmd.ports import CmsClient
-from ssb_pubmd.ports import ContentFileHandler
-from ssb_pubmd.ports import SecretManagerClient
-
-
-@dataclass
-class EnonicCmsManager:
-    """A CMS Mananager tailored to the Enonic CMS."""
-
-    config: Config
-    cms_client: CmsClient
-    secret_manager_client: SecretManagerClient
-    content_file_handler: ContentFileHandler
-
-    def sync(self, content_file_path: str) -> str:
-        """Requests that Enonic stores/updates the given contant file and gives back a rendered preview.
-
-        The details of the communication are handled by the CmsClient implementation, which in turn depends on the services that are exposed by the Enonic XP application. The only thing this class cares is that it receives a CmsResponse object, which contains an id and preview url of the content.
-        """
-        content = self.content_file_handler.get_content(Path(content_file_path))
-        response = self.cms_client.send(
-            token=self.secret_manager_client.generate_token(),
-            content=content,
-        )
-        self.content_file_handler.set_file_id(content.file_path, response.id)
-        return response.preview_url

ssb_pubmd/models.py

@@ -1,28 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass
-class CmsResponse:
-    id: str
-    preview_url: str
-
-
-@dataclass
-class Content:
-    content_id: str
-    file_path: Path
-    markdown: str
-
-    @property
-    def display_name(self) -> str:
-        """Generate a display name for the content."""
-        return self.file_path.stem.replace("_", " ").title()
-
-    def to_json(self) -> dict[str, str]:
-        """Returns a json representation of the content."""
-        return {
-            "_id": self.content_id,
-            "displayName": self.display_name,
-            "markdown": self.markdown,
-        }