crieur 2.0.2__py3-none-any.whl

crieur/__init__.py

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

crieur/__main__.py

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

crieur/cli.py

@@ -0,0 +1,169 @@
+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_feed, generate_html
+from .models import Settings, collect_authors, 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: str = "Crieur",
+    base_url: str = "/",
+    extra_vars: str = "",
+    target_path: Path = Path() / "public",
+    source_path: Path = Path() / "sources",
+    statics_path: Path = Path(__file__).parent / "statics",
+    templates_path: Path = Path(__file__).parent / "templates",
+    csl_path: Path = Path(__file__).parent / "styles" / "apa.csl",
+    without_statics: bool = False,
+    feed_limit: int = 10,
+):
+    """Generate a new revue website.
+
+    :title: Title of the website (default: Crieur).
+    :base_url: Base URL of the website, ending with / (default: /).
+    :extra_vars: stringified JSON extra vars passed to the templates.
+    :target_path: Path where site is built (default: /public/).
+    :source_path: Path where stylo source were downloaded (default: /sources/).
+    :statics_path: Path where statics are located (default: @crieur/statics/).
+    :template_path: Path where templates are located (default: @crieur/templates/).
+    :csl_path: Path to the CSL applied for bibliography (default: @crieur/styles/apa.csl).
+    :without_statics: Do not copy statics if True (default: False).
+    :feed_limit: Number of max items in the feed (default: 10).
+    """
+    settings = Settings(
+        title,
+        base_url,
+        extra_vars,
+        target_path,
+        source_path,
+        statics_path,
+        templates_path,
+        csl_path,
+        without_statics,
+        feed_limit,
+    )
+
+    numeros = []
+    for numero in each_folder_from(source_path):
+        for corpus_yaml in each_file_from(numero, pattern="*.yaml"):
+            numero = configure_numero(corpus_yaml, settings)
+            numeros.append(numero)
+
+    keywords = collect_keywords(numeros)
+    authors = collect_authors(numeros)
+    generate_html(numeros, keywords, authors, settings)
+    generate_feed(numeros, settings)
+
+    if not settings.without_statics:
+        target_statics_path = settings.target_path / "statics"
+        if not target_statics_path.exists():
+            target_statics_path.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(settings.statics_path, target_statics_path, 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)
+        else:
+            print(
+                f"Source already exists: `{zip_path}` (no download). "
+                "Use the `--force` option to download it again"
+            )
+
+        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 extracted to {target_path}")
+        except zipfile.BadZipFile:
+            zip_problematic_path = Path() / f"problematic-export-{i + 1}-{stylo_id}.zip"
+            zip_path.rename(zip_problematic_path)
+            print(f"Unable to find corpus with id {stylo_id}!")
+            print(
+                f"Check out the content of {zip_problematic_path} to try to understand."
+            )
+            print(
+                "Either you use a wrong corpus id or there is an issue with the export."
+            )
+            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,181 @@
+import json
+import locale
+import shutil
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import mistune
+from feedgen.feed import FeedGenerator
+from jinja2 import Environment as Env
+from jinja2 import FileSystemLoader
+from slugify import slugify
+
+from . import VERSION
+from .typography import typographie
+from .utils import neighborhood
+
+for locale_ in ["fr_FR", "fr_FR.UTF-8", "fr_CA", "fr_CA.UTF-8"]:
+    try:
+        locale.setlocale(locale.LC_ALL, locale_)
+        break
+    except locale.Error:
+        continue
+    locale.setlocale(locale.LC_ALL, "")
+
+
+mistune_plugins = [
+    "footnotes",
+    "superscript",
+    "table",
+    "crieur.plugins.inline_footnotes",
+]
+md = mistune.create_markdown(plugins=mistune_plugins, escape=False)
+
+
+def slugify_(value):
+    return slugify(value)
+
+
+def markdown(value):
+    return md(value) if value else ""
+
+
+def typography(value):
+    value = value.replace("\\ ", " ")
+    value = value.replace("'", "’")
+    return typographie(value) if value else ""
+
+
+def pluralize(number, singular="", plural="s"):
+    if number == 1:
+        return singular
+    else:
+        return plural
+
+
+def generate_html(numeros, keywords, authors, settings):
+    environment = Env(
+        loader=FileSystemLoader(
+            [str(settings.templates_path), str(Path(__file__).parent / "templates")]
+        )
+    )
+    environment.filters["slugify"] = slugify_
+    environment.filters["markdown"] = markdown
+    environment.filters["typography"] = typography
+    environment.filters["pluralize"] = pluralize
+
+    extra_vars = json.loads(settings.extra_vars) if settings.extra_vars else {}
+
+    common_params = {
+        "title": settings.title,
+        "base_url": settings.base_url,
+        "numeros": numeros,
+        "articles": sorted(
+            [article for numero in numeros for article in numero.articles], reverse=True
+        ),
+        "keywords": keywords,
+        "authors": authors,
+        "crieur_version": VERSION,
+        **extra_vars,
+    }
+
+    template_homepage = environment.get_template("homepage.html")
+    content = template_homepage.render(is_homepage=True, **common_params)
+    settings.target_path.mkdir(parents=True, exist_ok=True)
+    (settings.target_path / "index.html").write_text(content)
+
+    template_numeros = environment.get_template("numeros.html")
+    content = template_numeros.render(is_numeros=True, **common_params)
+    numeros_folder = settings.target_path / "numero"
+    numeros_folder.mkdir(parents=True, exist_ok=True)
+    (numeros_folder / "index.html").write_text(content)
+
+    template_blog = environment.get_template("blog.html")
+    content = template_blog.render(is_blog=True, **common_params)
+    blog_folder = settings.target_path / "blog"
+    blog_folder.mkdir(parents=True, exist_ok=True)
+    (blog_folder / "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 = settings.target_path / "numero" / numero.slug
+        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,
+                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
+                )
+
+    template_keywords = environment.get_template("keywords.html")
+    content = template_keywords.render(is_keywords=True, **common_params)
+    keywords_folder = settings.target_path / "mot-clef"
+    keywords_folder.mkdir(parents=True, exist_ok=True)
+    (keywords_folder / "index.html").write_text(content)
+
+    for slug, keyword in keywords.items():
+        template_keyword = environment.get_template("keyword.html")
+        content = template_keyword.render(keyword=keyword, **common_params)
+        keyword_folder = settings.target_path / "mot-clef" / keyword.slug
+        keyword_folder.mkdir(parents=True, exist_ok=True)
+        (keyword_folder / "index.html").write_text(content)
+
+    template_authors = environment.get_template("authors.html")
+    content = template_authors.render(is_authors=True, **common_params)
+    authors_folder = settings.target_path / "auteur"
+    authors_folder.mkdir(parents=True, exist_ok=True)
+    (authors_folder / "index.html").write_text(content)
+
+    for slug, author in authors.items():
+        template_author = environment.get_template("author.html")
+        content = template_author.render(author=author, **common_params)
+        author_folder = settings.target_path / "auteur" / author.slug
+        author_folder.mkdir(parents=True, exist_ok=True)
+        (author_folder / "index.html").write_text(content)
+
+
+def generate_feed(numeros, settings, lang="fr"):
+    feed = FeedGenerator()
+    feed.id(settings.base_url)
+    feed.title(settings.title)
+    feed.link(href=settings.base_url, rel="alternate")
+    feed.link(href=f"{settings.base_url}feed.xml", rel="self")
+    feed.language(lang)
+
+    articles = sorted(
+        [article for numero in numeros for article in numero.articles], reverse=True
+    )
+
+    for article in articles[: settings.feed_limit]:
+        feed_entry = feed.add_entry(order="append")
+        feed_entry.id(f"{settings.base_url}{article.url}")
+        feed_entry.title(article.title_f)
+        feed_entry.link(href=f"{settings.base_url}{article.url}")
+        feed_entry.updated(
+            datetime.combine(
+                article.date,
+                datetime.min.time(),
+                tzinfo=timezone(timedelta(hours=-4), "ET"),
+            )
+        )
+        for author in article.authors:
+            feed_entry.author(name=str(author))
+        feed_entry.summary(summary=article.content_html, type="html")
+        if article.keywords:
+            for keyword in article.keywords:
+                feed_entry.category(term=keyword.name)
+
+    feed.atom_file(settings.target_path / "feed.xml", pretty=True)
+    print(f"Generated meta-feed with {settings.feed_limit} items.")