crieur 1.0.0__py3-none-any.whl

crieur/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+VERSION = "1.0.0"
+ROOT_DIR = Path(__file__).parent

crieur/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

crieur/cli.py

@@ -0,0 +1,124 @@
+import contextlib
+import shutil
+import socket
+import zipfile
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer, test
+from pathlib import Path
+
+import httpx
+from minicli import cli, run
+
+from . import VERSION
+from .generator import generate_html
+from .models import collect_keywords, configure_numero
+from .utils import each_file_from, each_folder_from
+
+
+@cli
+def version():
+    """Return the current version."""
+    print(f"Crieur version: {VERSION}")
+
+
+@cli
+def generate(
+    title="Crieur",
+    target_path: Path = Path() / "public",
+    source_path: Path = Path() / "sources",
+):
+    """Generate a new revue website.
+
+    :title: Title of the website (default: Crieur).
+    :target_path: Path where site is built (default: /public/).
+    :source_path: Path where stylo source were downloaded (default: /sources/).
+    """
+    numeros = []
+    for numero in each_folder_from(source_path):
+        for corpus_yaml in each_file_from(numero, pattern="*.yaml"):
+            numero = configure_numero(corpus_yaml)
+            numeros.append(numero)
+
+    keywords = collect_keywords(numeros)
+    generate_html(title, numeros, keywords, target_path)
+
+    static_path_local = Path(__file__).parent / "statics"
+    shutil.copytree(static_path_local, target_path / "statics", dirs_exist_ok=True)
+
+
+@cli
+def stylo(
+    *stylo_ids: str,
+    stylo_instance: str = "stylo.huma-num.fr",
+    stylo_export: str = "https://export.stylo.huma-num.fr",
+    force_download: bool = False,
+):
+    """Initialize a new revue to current directory from Stylo.
+
+    :stylo_ids: Corpus ids from Stylo, separated by commas.
+    :stylo_instance: Instance of Stylo (default: stylo.huma-num.fr).
+    :stylo_export: Stylo export URL (default: https://export.stylo.huma-num.fr).
+    :force_download: Force download of sources from Stylo (default: False).
+    """
+    print(
+        f"Initializing a new revue: `{stylo_ids}` from `{stylo_instance}` "
+        f"through export service `{stylo_export}`."
+    )
+
+    sources_path = Path() / "sources"
+    if not sources_path.exists():
+        Path.mkdir(sources_path)
+
+    for i, stylo_id in enumerate(stylo_ids):
+        zip_path = Path() / f"export-{i + 1}-{stylo_id}.zip"
+        if force_download or not zip_path.exists():
+            url = (
+                f"{stylo_export}/generique/corpus/export/"
+                f"{stylo_instance}/{stylo_id}/Extract-corpus/"
+                "?with_toc=0&with_ascii=0&with_link_citations=0&with_nocite=0"
+                "&version=&bibliography_style=chicagomodified&formats=originals"
+            )
+            print(f"Downloading data from {url} to {zip_path}")
+            with Path.open(zip_path, "wb") as fd:
+                with httpx.stream("GET", url, timeout=None) as r:
+                    for data in r.iter_bytes():
+                        fd.write(data)
+
+        target_path = sources_path / f"{i + 1}-{stylo_id}"
+        try:
+            with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                zip_ref.extractall(target_path)
+            print(f"Data downloaded and extracted to {target_path}")
+        except zipfile.BadZipFile:
+            print(f"Unable to find corpus with id {stylo_id}!")
+            return
+
+
+@cli
+def serve(repository_path: Path = Path(), port: int = 8000):
+    """Serve an HTML book from `repository_path`/public or current directory/public.
+
+    :repository_path: Absolute or relative path to book’s sources (default: current).
+    :port: Port to serve the book from (default=8000)
+    """
+    print(
+        f"Serving HTML book from `{repository_path}/public` to http://127.0.0.1:{port}"
+    )
+
+    # From https://github.com/python/cpython/blob/main/Lib/http/server.py#L1307-L1326
+    class DirectoryServer(ThreadingHTTPServer):
+        def server_bind(self):
+            # suppress exception when protocol is IPv4
+            with contextlib.suppress(Exception):
+                self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+            return super().server_bind()
+
+        def finish_request(self, request, client_address):
+            self.RequestHandlerClass(
+                request, client_address, self, directory=str(repository_path / "public")
+            )
+
+    test(HandlerClass=SimpleHTTPRequestHandler, ServerClass=DirectoryServer, port=port)
+
+
+def main():
+    run()

crieur/generator.py

@@ -0,0 +1,73 @@
+import locale
+import shutil
+from pathlib import Path
+
+import mistune
+from jinja2 import Environment as Env
+from jinja2 import FileSystemLoader
+from slugify import slugify
+
+from .utils import neighborhood
+
+locale.setlocale(locale.LC_ALL, "fr_FR.UTF-8")
+environment = Env(loader=FileSystemLoader(str(Path(__file__).parent / "templates")))
+
+
+def slugify_(value):
+    return slugify(value)
+
+
+environment.filters["slugify"] = slugify_
+
+md = mistune.create_markdown(plugins=["footnotes", "superscript"])
+
+
+def markdown(value):
+    return md(value) if value else ""
+
+
+environment.filters["markdown"] = markdown
+
+
+def generate_html(title, numeros, keywords, target_path):
+    common_params = {
+        "numeros": numeros,
+        "keywords": keywords,
+        "title": title,
+    }
+
+    template_homepage = environment.get_template("homepage.html")
+    content = template_homepage.render(**common_params)
+    target_path.mkdir(parents=True, exist_ok=True)
+    (target_path / "index.html").write_text(content)
+
+    for numero in numeros:
+        template_numero = environment.get_template("numero.html")
+        content = template_numero.render(numero=numero, **common_params)
+        numero_folder = target_path / "numero" / numero.name
+        numero_folder.mkdir(parents=True, exist_ok=True)
+        (numero_folder / "index.html").write_text(content)
+
+        template_article = environment.get_template("article.html")
+        for index, previous, article, next_ in neighborhood(numero.articles):
+            content = template_article.render(
+                article=article,
+                numero=numero,
+                previous_situation=previous,
+                next_situation=next_,
+                **common_params,
+            )
+            article_folder = numero_folder / "article" / article.id
+            article_folder.mkdir(parents=True, exist_ok=True)
+            (article_folder / "index.html").write_text(content)
+            if article.images_path:
+                shutil.copytree(
+                    article.images_path, article_folder / "images", dirs_exist_ok=True
+                )
+
+    for slug, keyword in keywords.items():
+        template_keyword = environment.get_template("keyword.html")
+        content = template_keyword.render(keyword=keyword, **common_params)
+        keyword_folder = target_path / "mot-clef" / keyword.slug
+        keyword_folder.mkdir(parents=True, exist_ok=True)
+        (keyword_folder / "index.html").write_text(content)

crieur/models.py

@@ -0,0 +1,112 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from dataclass_wizard import DatePattern, DumpMeta, YAMLWizard
+from slugify import slugify
+from yaml.composer import ComposerError
+
+
+@dataclass
+class Numero(YAMLWizard):
+    _id: str
+    name: str
+    description: str
+    metadata: str
+    articles: list
+
+    def configure_articles(self, yaml_path):
+        # Preserves abstract_fr key (vs. abstract-fr) when converting to_yaml()
+        DumpMeta(key_transform="SNAKE").bind_to(Article)
+
+        loaded_articles = []
+        for article in self.articles:
+            article_folder = (
+                yaml_path.parent
+                / f"{article['article']['title']}-{article['article']['_id']}"
+            )
+            article_yaml_path = article_folder / f"{article['article']['title']}.yaml"
+            try:
+                loaded_article = Article.from_yaml_file(article_yaml_path)
+            except ComposerError:
+                loaded_article = Article.from_yaml(
+                    article_yaml_path.read_text().split("---")[1]
+                )
+            loaded_article.content_md = (
+                article_folder / f"{article['article']['title']}.md"
+            ).read_text()
+            loaded_article.images_path = (
+                article_folder / "images"
+                if (article_folder / "images").exists()
+                else None
+            )
+            loaded_article.numero = self
+            loaded_articles.append(loaded_article)
+        self.articles = loaded_articles
+
+
+@dataclass
+class Article(YAMLWizard):
+    id: str
+    title: str
+    title_f: str
+    date: Optional[DatePattern["%Y/%m/%d"]]  # noqa: F722
+    subtitle: str = ""
+    subtitle_f: str = ""
+    content_md: str = ""
+    authors: list = None
+    abstract: list = None
+    keywords: list = None
+
+
+def configure_numero(yaml_path):
+    # Preserves abstract_fr key (vs. abstract-fr) when converting to_yaml()
+    DumpMeta(key_transform="SNAKE").bind_to(Numero)
+
+    try:
+        numero = Numero.from_yaml_file(yaml_path)
+    except ComposerError:
+        numero = Numero.from_yaml(yaml_path.read_text().split("---")[1])
+
+    numero.configure_articles(yaml_path)
+    return numero
+
+
+@dataclass
+class Keyword:
+    slug: str
+    name: str
+    articles: list
+
+    def __eq__(self, other):
+        return self.slug == other.slug
+
+    def __lt__(self, other: "Keyword"):
+        if not isinstance(other, Keyword):
+            return NotImplemented
+        len_self = len(self.articles)
+        len_other = len(other.articles)
+        if len_self == len_other:
+            return self.slug > other.slug
+        return len_self < len_other
+
+
+def collect_keywords(numeros):
+    keywords = {}
+    for numero in numeros:
+        for article in numero.articles:
+            article_keywords = []
+            for kwds in article.keywords:
+                if kwds.get("list") and kwds.get("lang") == "fr":  # TODO: en?
+                    for keyword in kwds.get("list", "").split(", "):
+                        keyword_slug = slugify(keyword)
+                        if keyword_slug in keywords:
+                            keywords[keyword_slug].articles.append(article)
+                            kw = keywords[keyword_slug]
+                        else:
+                            kw = Keyword(
+                                slug=keyword_slug, name=keyword, articles=[article]
+                            )
+                            keywords[keyword_slug] = kw
+                        article_keywords.append(kw)
+            article.keywords = article_keywords
+    return dict(sorted(keywords.items(), key=lambda item: item[1], reverse=True))