Add yaml header check

geotribu_cli/cli.py

@@ -29,6 +29,7 @@
  parser_comments_broadcast,
  parser_comments_latest,
  parser_comments_read,
+ parser_header_check,
  parser_images_optimizer,
  parser_latest_content,
  parser_mastodon_export,
@@ -223,6 +224,16 @@ def main(args: list[str] = None):
  add_common_arguments(subcmd_upgrade)
  parser_upgrade(subcmd_upgrade)
 
+ subcmd_header_check = subparsers.add_parser(
+ "header-check",
+ aliases=["header", "check", "header-check", "metadata"],
+ help="Vérifier entête markdown",
+ formatter_class=main_parser.formatter_class,
+ prog="header-check",
+ )
+ add_common_arguments(subcmd_header_check)
+ parser_header_check(subcmd_header_check)
+
  # -- NESTED SUBPARSER : CREATE ---------------------------------------------------
  subcmd_content_manager = subparsers.add_parser(
  "creer",

geotribu_cli/content/header_check.py

@@ -0,0 +1,192 @@
+import argparse
+import logging
+import os
+import shutil
+import uuid
+
+import requests
+import yaml
+from PIL import Image
+
+from geotribu_cli.__about__ import __executable_name__, __version__
+from geotribu_cli.constants import GeotribuDefaults
+from geotribu_cli.content.json_feed import JsonFeedClient
+
+logger = logging.getLogger(__name__)
+defaults_settings = GeotribuDefaults()
+
+MANDATORY_KEYS = [
+ "title",
+ "subtitle",
+ "authors",
+ "categories",
+ "date",
+ "description",
+ "icon",
+ "license",
+ "tags",
+]
+
+# ############################################################################
+# ########## CLI #################
+# ################################
+
+
+def parser_header_check(
+ subparser: argparse.ArgumentParser,
+) -> argparse.ArgumentParser:
+ """Set the argument parser subcommand.
+
+ Args:
+ subparser (argparse.ArgumentParser): parser to set up
+
+ Returns:
+ argparse.ArgumentParser: parser ready to use
+ """
+ subparser.add_argument(
+ "content_path",
+ help="Chemin du fichier markdown dont l'entête est à vérifier",
+ type=str,
+ metavar="content",
+ )
+ subparser.add_argument(
+ "-minr",
+ "--min-ratio",
+ dest="min_image_ratio",
+ default=1.2,
+ help="Ratio width/height minimum de l'image à vérifier",
+ )
+ subparser.add_argument(
+ "-maxr",
+ "--max-ratio",
+ dest="max_image_ratio",
+ default=1.5,
+ help="Ratio width/height maximum de l'image à vérifier",
+ )
+ subparser.add_argument(
+ "-r",
+ "--raise",
+ dest="raise_exceptions",
+ action="store_true",
+ default=False,
+ help="Lever des exceptions et donc arrêter le programme si des erreurs sont rencontrées",
+ )
+ subparser.set_defaults(func=run)
+ return subparser
+
+
+# ############################################################################
+# ########## MAIN ################
+# ################################
+
+
+def check_image_ratio(image_url: str, min_ratio: float, max_ratio: float) -> bool:
+ r = requests.get(
+ image_url,
+ headers={"User-Agent": f"{__executable_name__}v{__version__}"},
+ stream=True,
+ )
+ r.raise_for_status()
+ image_file_name = str(uuid.uuid4())
+ with open(image_file_name, "wb") as image_file:
+ r.raw.decode_content = True
+ try:
+ shutil.copyfileobj(r.raw, image_file)
+ with Image.open(image_file_name) as image:
+ width, height = image.width, image.height
+ ratio = width / height
+ return min_ratio <= ratio <= max_ratio
+ finally:
+ os.remove(image_file_name)
+
+
+def get_existing_tags() -> set[str]:
+ jfc = JsonFeedClient()
+ return jfc.get_tags(should_sort=True)
+
+
+def check_existing_tags(tags: list[str]) -> tuple[bool, set[str], set[str]]:
+ existing_tags = get_existing_tags()
+ all_exists = set(tags).issubset(existing_tags)
+ missing = set(tags).difference(existing_tags)
+ present = set(tags).intersection(existing_tags)
+ return all_exists, missing, present
+
+
+def check_tags_order(tags: list[str]) -> bool:
+ for i in range(len(tags) - 1):
+ if tags[i] > tags[i + 1]:
+ return False
+ return True
+
+
+def check_mandatory_keys(
+ keys: list[str], mandatory: list[str] = MANDATORY_KEYS
+) -> tuple[bool, set[str]]:
+ missing = set()
+ for mk in mandatory:
+ if mk not in keys:
+ missing.add(mk)
+ return len(missing) == 0, missing
+
+
+def run(args: argparse.Namespace) -> None:
+ """Run the sub command logic.
+
+ Checks YAML header of a content
+
+ Args:
+ args (argparse.Namespace): arguments passed to the subcommand
+ """
+ logger.debug(f"Running {args.command} with {args}")
+ content_path = args.content_path
+
+ if not os.path.exists(content_path):
+ raise ValueError(f"Mayday ! Le fichier {content_path} n'existe pas !")
+
+ with open(content_path) as file:
+ content = file.read()
+ _, front_matter, _ = content.split("---", 2)
+ yaml_meta = yaml.safe_load(front_matter)
+ logger.debug(f"YAML metadata loaded : {yaml_meta}")
+
+ # check that image ratio is okayyy
+ if "image" in yaml_meta:
+ if not check_image_ratio(
+ yaml_meta["image"], args.min_image_ratio, args.max_image_ratio
+ ):
+ msg = f"Le ratio de l'image n'est pas dans l'interface autorisé ({args.minratio} - {args.maxratio})"
+ logger.error(msg)
+ if args.raise_exceptions:
+ raise ValueError(msg)
+ else:
+ logger.info("Ratio image ok")
+
+ # check that tags already exist
+ all_exists, missing, _ = check_existing_tags(yaml_meta["tags"])
+ if not all_exists:
+ msg = f"Les tags suivants n'existent pas dans les contenus Geotribu précédents : {','.join(missing)}"
+ logger.error(msg)
+ if args.raise_exceptions:
+ raise ValueError(msg)
+ else:
+ logger.info("Existence des tags ok")
+
+ # check if tags are alphabetically sorted
+ if not check_tags_order(yaml_meta["tags"]):
+ msg = "Les tags ne sont pas triés par ordre alphabétique"
+ logger.error(msg)
+ if args.raise_exceptions:
+ raise ValueError(msg)
+ else:
+ logger.info("Ordre alphabétique des tags ok")
+
+ # check that mandatory keys are present
+ all_present, missing = check_mandatory_keys(yaml_meta.keys(), MANDATORY_KEYS)
+ if not all_present:
+ msg = f"Les clés suivantes ne sont pas présentes dans l'entête markdown : {','.join(missing)}"
+ logger.error(msg)
+ if args.raise_exceptions:
+ raise ValueError(msg)
+ else:
+ logger.info("Clés de l'entête ok")

geotribu_cli/content/json_feed.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+import requests
+from requests import Response
+
+from geotribu_cli.__about__ import __executable_name__, __version__
+
+HEADERS: dict = {
+ b"Accept": b"application/json",
+ b"User-Agent": bytes(f"{__executable_name__}/{__version__}", "utf8"),
+}
+
+
+class JsonFeedClient:
+ def __init__(self, url: str = "https://geotribu.fr/feed_json_created.json"):
+ """Class initialization."""
+ self.url = url
+
+ @property
+ def get_items(self) -> list[dict[str, Any]]:
+ r: Response = requests.get(self.url, headers=HEADERS)
+ r.raise_for_status()
+ return r.json()["items"]
+
+ def get_tags(self, should_sort: bool = False) -> set[str]:
+ tags = set().union(*[i["tags"] for i in self.get_items])
+ return sorted(tags) if should_sort else tags

geotribu_cli/subcommands/__init__.py

@@ -4,6 +4,7 @@
 from geotribu_cli.comments import parser_comments_broadcast # noqa: F401
 from geotribu_cli.comments import parser_comments_latest # noqa: F401
 from geotribu_cli.comments import parser_comments_read # noqa: F401
+from geotribu_cli.content.header_check import parser_header_check # noqa: F401
 from geotribu_cli.content.new_article import parser_new_article # noqa: F401
 from geotribu_cli.images.images_optimizer import parser_images_optimizer # noqa: F401
 from geotribu_cli.rss.rss_reader import parser_latest_content # noqa: F401

tests/fixtures/content/2012-12-21_article_passe.md

@@ -0,0 +1,20 @@
+---
+title: Article supposément rédigé dans le passé
+subtitle: Article supposément rédigé dans le passé pour tests
+authors:
+ - Jane Doe
+categories:
+ - article
+comments: true
+date: 2012-12-21
+description: Article supposément rédigé dans le passé
+icon: octicons/server-16
+license: beerware
+robots: index, follow
+tags:
+ - Fromage
+ - OSM
+ - QGIS
+---
+
+# Article supposément rédigé dans le futur

tests/fixtures/content/2044-04-01_article_futur.md

@@ -0,0 +1,19 @@
+---
+title: Article supposément rédigé dans le futur
+subtitle: Article supposément rédigé dans le futur pour tests
+authors:
+ - Jane Doe
+categories:
+ - article
+comments: true
+date: 2044-04-01
+icon: octicons/server-16
+robots: index, follow
+tags:
+ - Fromage
+ - IGN
+ - QGIS
+ - OSM
+---
+
+# Article supposément rédigé dans le futur

tests/test_yaml_header_check.py

@@ -0,0 +1,64 @@
+import unittest
+from unittest.mock import patch
+
+import yaml
+
+from geotribu_cli.content.header_check import (
+ check_existing_tags,
+ check_mandatory_keys,
+ check_tags_order,
+)
+
+
+class TestYamlHeaderCheck(unittest.TestCase):
+ def setUp(self):
+ with open("tests/fixtures/content/2012-12-21_article_passe.md") as past_file:
+ past_content = past_file.read()
+ _, front_matter, _ = past_content.split("---", 2)
+ self.past_yaml_meta = yaml.safe_load(front_matter)
+
+ with open("tests/fixtures/content/2044-04-01_article_futur.md") as future_file:
+ future_content = future_file.read()
+ _, front_matter, _ = future_content.split("---", 2)
+ self.future_yaml_meta = yaml.safe_load(front_matter)
+
+ @patch("geotribu_cli.content.header_check.get_existing_tags")
+ def test_past_tags_existence(self, get_existing_tags_mock):
+ get_existing_tags_mock.return_value = ["QGIS", "OSM"]
+ tags_ok, missing_tags, present_tags = check_existing_tags(
+ self.past_yaml_meta["tags"]
+ )
+ self.assertFalse(tags_ok)
+ self.assertIn("Fromage", missing_tags)
+ self.assertIn("QGIS", present_tags)
+ self.assertIn("OSM", present_tags)
+
+ @patch("geotribu_cli.content.header_check.get_existing_tags")
+ def test_future_tags_existence(self, get_existing_tags_mock):
+ get_existing_tags_mock.return_value = ["Fromage", "IGN"]
+ tags_ok, missing_tags, present_tags = check_existing_tags(
+ self.future_yaml_meta["tags"]
+ )
+ self.assertFalse(tags_ok)
+ self.assertIn("QGIS", missing_tags)
+ self.assertIn("OSM", missing_tags)
+ self.assertIn("Fromage", present_tags)
+ self.assertIn("IGN", present_tags)
+
+ def test_past_tags_order(self):
+ self.assertTrue(check_tags_order(self.past_yaml_meta["tags"]))
+
+ def test_future_tags_order(self):
+ self.assertFalse(check_tags_order(self.future_yaml_meta["tags"]))
+
+ def test_past_mandatory_keys(self):
+ all_present, missing = check_mandatory_keys(self.past_yaml_meta.keys())
+ self.assertTrue(all_present)
+ self.assertEqual(len(missing), 0)
+
+ def test_future_mandatory_keys(self):
+ all_present, missing = check_mandatory_keys(self.future_yaml_meta.keys())
+ self.assertFalse(all_present)
+ self.assertEqual(len(missing), 2)
+ self.assertIn("license", missing)
+ self.assertIn("description", missing)