ssb-pubmd 0.0.16__tar.gz → 0.0.17__tar.gz

{ssb_pubmd-0.0.16 → ssb_pubmd-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ssb-pubmd
-Version: 0.0.16
+Version: 0.0.17
 Summary: SSB Pubmd
 License: MIT
 Author: Olav Landsverk
@@ -14,9 +14,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: click (>=8.0.1)
+Requires-Dist: google-cloud-secret-manager (>=2.24.0,<3.0.0)
 Requires-Dist: nbformat (>=5.10.4,<6.0.0)
 Requires-Dist: platformdirs (>=4.3.8,<5.0.0)
 Requires-Dist: playwright (>=1.51.0,<2.0.0)
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: types-requests (>=2.32.0.20250306,<3.0.0.0)
 Project-URL: Changelog, https://github.com/statisticsnorway/ssb-pubmd/releases

{ssb_pubmd-0.0.16 → ssb_pubmd-0.0.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-pubmd"
-version = "0.0.16"
+version = "0.0.17"
 description = "SSB Pubmd"
 authors = ["Olav Landsverk <stud-oll@ssb.no>"]
 license = "MIT"
@@ -21,6 +21,8 @@ requests = "^2.32.3"
 types-requests = "^2.32.0.20250306"
 playwright = "^1.51.0"
 platformdirs = "^4.3.8"
+pyjwt = "^2.10.1"
+google-cloud-secret-manager = "^2.24.0"
 
 [tool.poetry.group.dev.dependencies]
 pygments = ">=2.10.0"

{ssb_pubmd-0.0.16 → ssb_pubmd-0.0.17}/src/ssb_pubmd/__main__.py

@@ -14,14 +14,18 @@ from ssb_pubmd.browser_request_handler import CreateContextMethod
 from ssb_pubmd.constants import APP_NAME
 from ssb_pubmd.constants import CACHE_FILE
 from ssb_pubmd.constants import CONFIG_FILE
+from ssb_pubmd.jwt_request_handler import JWTRequestHandler
 from ssb_pubmd.markdown_syncer import MarkdownSyncer
 
 
 class ConfigKey(Enum):
     """Configuration keys for the application."""
 
+    BASE_URL = "base_url"
     LOGIN_URL = "login_url"
     POST_URL = "post_url"
+    AUTH_METHOD = "auth_method"
+    GC_SECRET_RESOURCE_NAME = "gc_secret_resource_name"
 
 
 def get_config_value(config_key: ConfigKey) -> str:
@@ -94,9 +98,7 @@ def login() -> None:
     click.echo(f"\nBrowser context stored in:\n{CACHE_FILE}")
 
 
-@cli.command()
-@click.argument("content_file_path", type=click.Path())
-def sync(content_file_path: str) -> None:
+def sync_with_browser(content_file_path: str) -> None:
     """Sync a markdown or notebook file to the CMS."""
     login_url = get_config_value(ConfigKey.LOGIN_URL)
     request_handler = BrowserRequestHandler(CACHE_FILE, login_url)
@@ -122,5 +124,38 @@ def sync(content_file_path: str) -> None:
             click.echo("No preview url found in the response.")
 
 
+def sync_with_jwt(content_file_path: str) -> None:
+    """Sync a markdown or notebook file to the CMS."""
+    gc_secret_resource_name = get_config_value(ConfigKey.GC_SECRET_RESOURCE_NAME)
+    request_handler = JWTRequestHandler(gc_secret_resource_name)
+
+    post_url = get_config_value(ConfigKey.POST_URL)
+    syncer = MarkdownSyncer(post_url, request_handler)
+
+    syncer.content_file_path = Path(content_file_path)
+    response = syncer.sync_content()
+
+    click.echo("Content synced successfully.")
+
+    preview_path = response.body.get("previewPath", "")
+    if preview_path:
+        base_url = get_config_value(ConfigKey.BASE_URL)
+        preview = urlparse(base_url)._replace(path=preview_path).geturl()
+        click.echo(f"Preview url found in the response: {preview}")
+    else:
+        click.echo("No preview url found in the response.")
+
+
+@cli.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."""
+    auth_method = get_config_value(ConfigKey.AUTH_METHOD)
+    if auth_method == "browser":
+        sync_with_browser(content_file_path)
+    else:
+        sync_with_jwt(content_file_path)
+
+
 if __name__ == "__main__":
     cli()

ssb_pubmd-0.0.17/src/ssb_pubmd/jwt_request_handler.py

@@ -0,0 +1,99 @@
+import json
+from dataclasses import dataclass
+from datetime import datetime
+
+import jwt
+import requests
+from google.cloud import secretmanager
+
+from ssb_pubmd.request_handler import Response
+
+TYPE = "JWT"
+ALGORITHM = "RS256"
+
+
+@dataclass
+class SecretData:
+    """Data class to hold private key and connected data."""
+
+    private_key: str
+    kid: str
+    principal_key: str
+
+
+class JWTRequestHandler:
+    """This class is used to send requests with a JSON Web Token (JWT) in the header."""
+
+    def __init__(self, gc_secret_resource_name: str) -> None:
+        """Initializes a JWT request handler object."""
+        self._gc_secret_resource_name: str = gc_secret_resource_name
+
+    def _private_key_from_secret_manager(self) -> SecretData:
+        """Fetches the private key from Google Cloud Secret Manager."""
+        client = secretmanager.SecretManagerServiceClient()
+        print(f"Fetching secret from {self._gc_secret_resource_name}")
+        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:
+            secret_data = SecretData(
+                private_key=data["privateKey"],
+                kid=data["kid"],
+                principal_key=data["principalKey"],
+            )
+        except KeyError as e:
+            raise ValueError(
+                "The secret must be a JSON object with keys 'privateKey', 'kid' and 'principalKey'."
+            ) from e
+        return secret_data
+
+    def _generate_token(self) -> str:
+        secret_data = self._private_key_from_secret_manager()
+
+        header = {
+            "kid": secret_data.kid,
+            "typ": TYPE,
+            "alg": ALGORITHM,
+        }
+
+        iat = int(datetime.now().timestamp())
+        exp = iat + 30
+        payload = {
+            "sub": secret_data.principal_key,
+            "iat": iat,
+            "exp": exp,
+        }
+
+        token = jwt.encode(
+            payload, secret_data.private_key, algorithm=ALGORITHM, headers=header
+        )
+        return token
+
+    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 with bearer token in header."""
+        token = self._generate_token()
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+        response = requests.post(
+            url,
+            headers=headers,
+            json=data,
+        )
+
+        try:
+            body = response.json()
+            body = dict(body)
+        except Exception:
+            body = {}
+
+        return Response(
+            status_code=response.status_code,
+            body=body,
+        )