memi-engine 0.2.0__tar.gz → 0.3.0__tar.gz

{memi_engine-0.2.0 → memi_engine-0.3.0}/PKG-INFO

@@ -1,8 +1,8 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: memi-engine
-Version: 0.2.0
+Version: 0.3.0
 Summary: Engine for building memi memory card game instances
-Project-URL: Homepage, https://memi.click
+Project-URL: Homepage, https://memi.games
 Project-URL: Repository, https://github.com/filias/memi-engine
 Project-URL: Issues, https://github.com/filias/memi-engine/issues
 Author-email: Filipa Andrade <filipa.andrade@gmail.com>
@@ -47,7 +47,7 @@ Description-Content-Type: text/markdown
 > between what you see and what you know. The answer is always one tap away — the
 > point is to reach for it yourself first.
 
-`memi-engine` lets you build your own [memi](https://memi.click) game — a
+`memi-engine` lets you build your own [memi](https://memi.games) game — a
 tap-to-reveal flashcard trainer — from a list of names and where to find their
 images.
 
@@ -219,6 +219,10 @@ Passed to `create_app`. Common fields:
 | `wikipedia_lang`  | `"en"`               | Wikipedia edition for default images / *know more* links. |
 | `related_sites`   | `[]`                 | Sibling games to link from the about page. |
 | `label_*`         | English strings      | UI labels (for localization).            |
+| `html_lang`       | `"en"`               | `<html lang>` — set it for a non-English game. |
+| `site_url`        | `None`               | Canonical origin; taken from the request if unset. |
+| `description`     | `""`                 | Home page meta description; falls back to `about_html`. |
+| `og_image`        | `None`               | Link-preview image (absolute URL).       |
 
 For a non-English game, set `wikipedia_lang` so the default image lookup and the
 *"know more"* link resolve against that language's Wikipedia (e.g. `"pt"`). It
@@ -237,6 +241,44 @@ app = create_app(config, instance_static="/path/to/static")
 # served at /static/... , falling back to the engine's static files
 ```
 
+## Search discoverability
+
+One game is served from many URLs: `/`, a `/<slug>` landing page per category,
+and `/about`. The category you are playing is a JavaScript variable, so nothing
+in the markup distinguishes those pages — left alone they are one page repeated,
+and a crawler indexes one and discards the rest.
+
+The engine gives each of them its own metadata, derived from what the instance
+already declares:
+
+| Page | Title | Description | Canonical |
+| --- | --- | --- | --- |
+| `/` | `{title} — {subtitle}` | `description`, else the opening of `about_html` | `/` |
+| `/<slug>` | `{category} — {title}` | `{category} — {description}` | the category's short slug |
+| `/about` | `{label_about} — {title}` | as the home page | `/about` |
+
+The title and description patterns are `home_title`, `category_title` and
+`category_description` on `MemiConfig`; a category pattern can also use
+`{count}`, the number of items in it. Defaults are punctuation only, so a
+localized game stays in its own language without touching them.
+
+Two more things fall out of this:
+
+- **`/robots.txt`** opens the site, excludes `/api/` (JSON a crawler can do
+  nothing with) and names the sitemap.
+- **`/sitemap.xml`** lists `/`, `/about` and every category — built from the
+  registry, so a new provider appears without an edit. A category whose last
+  segment is unique answers at both `/food` and `/culture-food`; only the short
+  one is listed, and the long one canonicalises to it.
+
+Canonical and `og:` URLs need the site's real origin. Behind a reverse proxy
+that sends `X-Forwarded-Proto` and `X-Forwarded-Host` (Caddy does by default)
+the engine works it out per request. Set `site_url` — or `MEMI_SITE_URL` — to
+pin it instead.
+
+Set **`html_lang`** per instance. It defaults to `"en"`, and a Portuguese game
+that tells Google it is English is a game shown to the wrong people.
+
 ## Deployment
 
 The app is a standard WSGI Flask app. For production, install the `server`
@@ -253,9 +295,10 @@ players report a bad card).
 
 ## Live examples
 
-Real games built on this engine: [memi](https://memi.click) ·
-[memi portugal](https://pt.memi.click) · [memi lisboa](https://lx.memi.click) ·
-[memi slovensko](https://sk.memi.click) · [memi US](https://us.memi.click).
+Real games built on this engine, all linked from
+[memi.games](https://memi.games): [memi](https://world.memi.games) ·
+[memi portugal](https://pt.memi.games) · [memi lisboa](https://lx.memi.games) ·
+[memi slovensko](https://sk.memi.games) · [memi US](https://us.memi.games).
 
 ## Development
 

{memi_engine-0.2.0 → memi_engine-0.3.0}/README.md

@@ -14,7 +14,7 @@
 > between what you see and what you know. The answer is always one tap away — the
 > point is to reach for it yourself first.
 
-`memi-engine` lets you build your own [memi](https://memi.click) game — a
+`memi-engine` lets you build your own [memi](https://memi.games) game — a
 tap-to-reveal flashcard trainer — from a list of names and where to find their
 images.
 
@@ -186,6 +186,10 @@ Passed to `create_app`. Common fields:
 | `wikipedia_lang`  | `"en"`               | Wikipedia edition for default images / *know more* links. |
 | `related_sites`   | `[]`                 | Sibling games to link from the about page. |
 | `label_*`         | English strings      | UI labels (for localization).            |
+| `html_lang`       | `"en"`               | `<html lang>` — set it for a non-English game. |
+| `site_url`        | `None`               | Canonical origin; taken from the request if unset. |
+| `description`     | `""`                 | Home page meta description; falls back to `about_html`. |
+| `og_image`        | `None`               | Link-preview image (absolute URL).       |
 
 For a non-English game, set `wikipedia_lang` so the default image lookup and the
 *"know more"* link resolve against that language's Wikipedia (e.g. `"pt"`). It
@@ -204,6 +208,44 @@ app = create_app(config, instance_static="/path/to/static")
 # served at /static/... , falling back to the engine's static files
 ```
 
+## Search discoverability
+
+One game is served from many URLs: `/`, a `/<slug>` landing page per category,
+and `/about`. The category you are playing is a JavaScript variable, so nothing
+in the markup distinguishes those pages — left alone they are one page repeated,
+and a crawler indexes one and discards the rest.
+
+The engine gives each of them its own metadata, derived from what the instance
+already declares:
+
+| Page | Title | Description | Canonical |
+| --- | --- | --- | --- |
+| `/` | `{title} — {subtitle}` | `description`, else the opening of `about_html` | `/` |
+| `/<slug>` | `{category} — {title}` | `{category} — {description}` | the category's short slug |
+| `/about` | `{label_about} — {title}` | as the home page | `/about` |
+
+The title and description patterns are `home_title`, `category_title` and
+`category_description` on `MemiConfig`; a category pattern can also use
+`{count}`, the number of items in it. Defaults are punctuation only, so a
+localized game stays in its own language without touching them.
+
+Two more things fall out of this:
+
+- **`/robots.txt`** opens the site, excludes `/api/` (JSON a crawler can do
+  nothing with) and names the sitemap.
+- **`/sitemap.xml`** lists `/`, `/about` and every category — built from the
+  registry, so a new provider appears without an edit. A category whose last
+  segment is unique answers at both `/food` and `/culture-food`; only the short
+  one is listed, and the long one canonicalises to it.
+
+Canonical and `og:` URLs need the site's real origin. Behind a reverse proxy
+that sends `X-Forwarded-Proto` and `X-Forwarded-Host` (Caddy does by default)
+the engine works it out per request. Set `site_url` — or `MEMI_SITE_URL` — to
+pin it instead.
+
+Set **`html_lang`** per instance. It defaults to `"en"`, and a Portuguese game
+that tells Google it is English is a game shown to the wrong people.
+
 ## Deployment
 
 The app is a standard WSGI Flask app. For production, install the `server`
@@ -220,9 +262,10 @@ players report a bad card).
 
 ## Live examples
 
-Real games built on this engine: [memi](https://memi.click) ·
-[memi portugal](https://pt.memi.click) · [memi lisboa](https://lx.memi.click) ·
-[memi slovensko](https://sk.memi.click) · [memi US](https://us.memi.click).
+Real games built on this engine, all linked from
+[memi.games](https://memi.games): [memi](https://world.memi.games) ·
+[memi portugal](https://pt.memi.games) · [memi lisboa](https://lx.memi.games) ·
+[memi slovensko](https://sk.memi.games) · [memi US](https://us.memi.games).
 
 ## Development
 

{memi_engine-0.2.0 → memi_engine-0.3.0}/memi_engine/app.py

@@ -11,7 +11,6 @@ import logging
 import os
 import random
 import subprocess
-from collections import Counter
 
 from flask import (
     Flask,
@@ -22,8 +21,9 @@ from flask import (
     request,
     send_from_directory,
 )
+from werkzeug.middleware.proxy_fix import ProxyFix
 
-from memi_engine import images, registry
+from memi_engine import images, registry, seo
 from memi_engine.config import MemiConfig
 from memi_engine.menu import build_menu
 
@@ -54,6 +54,12 @@ def create_app(config: MemiConfig, instance_static: str | None = None) -> Flask:
         static_folder=None,
     )
 
+    # Every memi site runs behind Caddy, which terminates HTTPS and proxies to
+    # gunicorn on localhost. Without this the app only ever sees the plain-HTTP
+    # inner hop, and would publish canonical and og: URLs on http://127.0.0.1.
+    # One hop, and only the two headers that decide the origin.
+    app.wsgi_app = ProxyFix(app.wsgi_app, x_for=0, x_proto=1, x_host=1)
+
     # Custom static file handler: instance first, then engine
     static_dirs = (
         [instance_static, engine_static] if instance_static else [engine_static]
@@ -97,7 +103,26 @@ def create_app(config: MemiConfig, instance_static: str | None = None) -> Flask:
 
     # --- Routes ---
 
-    def _render_index(initial_category=None):
+    def _site_url() -> str:
+        """Origin that canonical, og: and sitemap URLs are built on."""
+        pinned = config.site_url or os.environ.get("MEMI_SITE_URL")
+        return (pinned or request.url_root).rstrip("/")
+
+    def _page(meta: dict, path: str) -> dict:
+        """Head metadata for one page: what it is, and where it really lives."""
+        return {
+            "title": meta["title"],
+            "description": meta["description"],
+            "canonical": _site_url() + path,
+            "og_image": config.og_image,
+        }
+
+    def _category_page_meta(key: str) -> dict:
+        provider = registry.get(key)
+        count = len(provider.items) if provider else 0
+        return seo.category_meta(config, key, count)
+
+    def _render_index(initial_category=None, page=None):
         top_level, subs = build_menu()
         # Collect all unique filters from all providers
         all_filters = _collect_filters()
@@ -109,6 +134,7 @@ def create_app(config: MemiConfig, instance_static: str | None = None) -> Flask:
             config=config,
             filters=all_filters,
             initial_category=initial_category,
+            page=page or _page(seo.home_meta(config), "/"),
         )
 
     @app.route("/")
@@ -120,21 +146,74 @@ def create_app(config: MemiConfig, instance_static: str | None = None) -> Flask:
         initial = cat if registry.get(cat) else None
         if initial is None and registry.get(config.default_category or ""):
             initial = config.default_category
-        return _render_index(initial)
+        # `?cat=` is the same page as that category's own URL, so it points at
+        # it rather than competing with it. A bare `/` is the home page and
+        # canonicalises to itself, even when a default category is showing.
+        page = None
+        if cat and initial:
+            slug = seo.canonical_slugs(registry.get_all()).get(initial)
+            if slug:
+                page = _page(_category_page_meta(initial), f"/{slug}")
+        return _render_index(initial, page)
 
     @app.route("/<slug>")
     def category_landing(slug):
         # Pretty per-category landing pages, e.g. /food -> culture:food.
-        key = _category_slugs().get(slug)
+        key = seo.category_slugs(registry.get_all()).get(slug)
         if key is None:
             abort(404)
-        return _render_index(key)
+        # A category with a unique last segment answers at both /food and
+        # /culture-food. Both keep working; the canonical names the short one
+        # so the pair is never indexed as two pages.
+        canonical = seo.canonical_slugs(registry.get_all()).get(key, slug)
+        return _render_index(key, _page(_category_page_meta(key), f"/{canonical}"))
 
     @app.route("/about")
     def about():
         return render_template(
-            "about.html", version=config.version, config=config
+            "about.html",
+            version=config.version,
+            config=config,
+            page=_page(seo.about_meta(config), "/about"),
+        )
+
+    @app.route("/robots.txt")
+    def robots_txt():
+        """Open the site to crawlers and point them at the sitemap.
+
+        The game data endpoints are excluded: they answer with JSON a crawler
+        can do nothing with, and /api/random is different on every request.
+        """
+        body = (
+            "User-agent: *\n"
+            "Allow: /\n"
+            "Disallow: /api/\n"
+            "\n"
+            f"Sitemap: {_site_url()}/sitemap.xml\n"
         )
+        return Response(body, mimetype="text/plain")
+
+    @app.route("/sitemap.xml")
+    def sitemap_xml():
+        """Every page worth indexing, built from the registry.
+
+        The category pages are reachable in the UI only by clicking a button,
+        so without this a crawler finds the home page and nothing else. A new
+        provider appears here the moment it registers — nothing to maintain.
+        """
+        base = _site_url()
+        paths = ["/", "/about"]
+        paths += [
+            f"/{slug}"
+            for slug in sorted(seo.canonical_slugs(registry.get_all()).values())
+        ]
+        urls = "".join(f"<url><loc>{base}{path}</loc></url>" for path in paths)
+        body = (
+            '<?xml version="1.0" encoding="UTF-8"?>'
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
+            f"{urls}</urlset>"
+        )
+        return Response(body, mimetype="application/xml")
 
     @app.route("/api/random")
     def random_item():
@@ -228,25 +307,6 @@ def create_app(config: MemiConfig, instance_static: str | None = None) -> Flask:
     return app
 
 
-def _category_slugs() -> dict[str, str]:
-    """Map shareable URL slugs to category keys, derived from the registry.
-
-    A category key's last ``:``-segment is its slug when that segment is unique
-    (``culture:food`` -> ``food``); the full dashed key is always available too
-    (``culture-food``), and is the *only* slug for segments that would collide
-    (e.g. several ``…:all`` categories, which all end in ``all``).
-    """
-    keys = list(registry.get_all())
-    last = {k: k.rsplit(":", 1)[-1] for k in keys}
-    counts = Counter(last.values())
-    slugs: dict[str, str] = {}
-    for k in keys:
-        if counts[last[k]] == 1:
-            slugs[last[k]] = k
-        slugs.setdefault(k.replace(":", "-"), k)
-    return slugs
-
-
 def _collect_filters() -> dict:
     """Collect all unique filters across all providers.
 

{memi_engine-0.2.0 → memi_engine-0.3.0}/memi_engine/config.py

@@ -68,3 +68,38 @@ class MemiConfig:
 
     # Wikipedia language edition for the default image / "know more" helpers.
     wikipedia_lang: str = "en"
+
+    # --- Search engines and link previews ---
+    #
+    # Every field here has a working default derived from the fields above, so
+    # a game gets per-page titles, descriptions and canonicals without setting
+    # any of them. See memi_engine/seo.py.
+
+    # Canonical origin, e.g. "https://pt.memi.games". Leave None to take it
+    # from the request (correct behind the usual Caddy reverse proxy, which
+    # sends X-Forwarded-Proto and X-Forwarded-Host). Set it — or the
+    # MEMI_SITE_URL env var — to pin canonical URLs to one host regardless of
+    # what a request claims.
+    site_url: str | None = None
+
+    # <html lang>. The engine is English; the games mostly are not, and a page
+    # that declares the wrong language is a page Google shows to the wrong
+    # people. Set it per instance ("pt", "sk", "ca").
+    html_lang: str = "en"
+
+    # Meta description for the home page. Empty falls back to the opening of
+    # about_html, which is already written in the instance's language.
+    description: str = ""
+
+    # Absolute URL of the link-preview image (og:image). None omits the tag;
+    # the card still renders from the title and description.
+    og_image: str | None = None
+
+    # Title patterns. Placeholders: {title}, {subtitle} and, for a category
+    # page, {category} — the category's label as the menu shows it.
+    home_title: str = "{title} — {subtitle}"
+    category_title: str = "{category} — {title}"
+
+    # Description pattern for a category page. {description} is the site
+    # description resolved above.
+    category_description: str = "{category} — {description}"

memi_engine-0.3.0/memi_engine/seo.py

@@ -0,0 +1,165 @@
+"""Search-engine metadata for a memi instance.
+
+The engine serves one game from many URLs — ``/``, a ``/<slug>`` landing page
+per category, and ``/about``. Until each of those carries its own title,
+description and canonical they are, to a crawler, the same page repeated: the
+category is only ever a JavaScript variable, so nothing in the markup says
+which one you are looking at.
+
+Everything here is derived from what an instance already declares — its title,
+subtitle, about copy and registered categories — so a game gets per-page
+metadata without adding configuration. The patterns on ``MemiConfig`` are the
+override for instances that want their own wording.
+"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+# Roughly where Google truncates the snippet. Not a hard rule on their side,
+# but a description that survives intact reads better than an ellipsis.
+DESCRIPTION_MAX = 160
+
+_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+_ENTITIES = {
+    "&mdash;": "—", "&ndash;": "–", "&nbsp;": " ",
+    "&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": '"', "&#39;": "'",
+}
+
+
+def strip_html(html: str) -> str:
+    """Plain text from a fragment of HTML, whitespace collapsed.
+
+    ``about_html`` is hand-written per instance and is the one place a game
+    already describes itself in its own language, which makes it the best
+    fallback for a meta description.
+    """
+    text = _TAG_RE.sub(" ", html or "")
+    for entity, char in _ENTITIES.items():
+        text = text.replace(entity, char)
+    return _WS_RE.sub(" ", text).strip()
+
+
+def shorten(text: str, limit: int = DESCRIPTION_MAX) -> str:
+    """Trim to ``limit`` characters, preferring a sentence then a word break."""
+    text = text.strip()
+    if len(text) <= limit:
+        return text
+    window = text[: limit + 1]
+    for end in (". ", "! ", "? "):
+        cut = window.rfind(end)
+        if cut > limit // 2:
+            return window[: cut + 1].strip()
+    cut = window.rfind(" ")
+    trimmed = (window[:cut] if cut > 0 else window[:limit]).rstrip(" ,;:-–—")
+    # A cut that happens to land on a full stop is already a clean ending; an
+    # ellipsis after it just reads as a typo.
+    return trimmed if trimmed.endswith((".", "!", "?")) else trimmed + "…"
+
+
+def category_label(key: str) -> str:
+    """Display label for a category key — its last segment, as the menu shows it.
+
+    ``"cultura:monumentos"`` -> ``"monumentos"``.
+    """
+    return key.rsplit(":", 1)[-1]
+
+
+def category_slugs(keys) -> dict[str, str]:
+    """Map every URL slug to its category key.
+
+    A key's last ``:``-segment is a slug when that segment is unique
+    (``culture:food`` -> ``food``); the full dashed key is always available too
+    (``culture-food``), and is the *only* slug for segments that would collide
+    (e.g. several ``…:all`` categories, which all end in ``all``).
+    """
+    keys = list(keys)
+    last = {k: category_label(k) for k in keys}
+    counts = Counter(last.values())
+    slugs: dict[str, str] = {}
+    for k in keys:
+        if counts[last[k]] == 1:
+            slugs[last[k]] = k
+        slugs.setdefault(k.replace(":", "-"), k)
+    return slugs
+
+
+def canonical_slugs(keys) -> dict[str, str]:
+    """Map each category key to the one slug that represents it.
+
+    The inverse of :func:`category_slugs`, and the reason it exists: a category
+    with a unique last segment is reachable at both ``/food`` and
+    ``/culture-food``. Both keep working — links to either are already out
+    there — but only the short one goes in the sitemap, and the long one
+    canonicalises to it, so the pair is never indexed as two pages.
+    """
+    preferred: dict[str, str] = {}
+    for slug, key in category_slugs(keys).items():
+        current = preferred.get(key)
+        if current is None or len(slug) < len(current):
+            preferred[key] = slug
+    return preferred
+
+
+def site_description(config) -> str:
+    """The instance's own description, in the instance's own language.
+
+    ``MemiConfig.description`` when set, else the opening of ``about_html``,
+    which every game writes in its own language. The title/subtitle pair is the
+    last resort: short, but never empty and never the wrong language.
+    """
+    if config.description:
+        return config.description
+    about = shorten(strip_html(config.about_html or ""))
+    return about or f"{config.title} — {config.subtitle}"
+
+
+def _format(pattern: str, **values: str) -> str:
+    """Apply a config pattern, tolerating a placeholder the instance dropped."""
+    try:
+        return pattern.format(**values).strip()
+    except (KeyError, IndexError):
+        return values.get("title", "")
+
+
+def home_meta(config) -> dict[str, str]:
+    return {
+        "title": _format(
+            config.home_title, title=config.title, subtitle=config.subtitle
+        ),
+        "description": site_description(config),
+    }
+
+
+def about_meta(config) -> dict[str, str]:
+    return {
+        "title": f"{config.label_about} — {config.title}",
+        "description": site_description(config),
+    }
+
+
+def category_meta(config, key: str, count: int = 0) -> dict[str, str]:
+    """Title and description for one category's landing page.
+
+    ``count`` is how many items the category holds; it is not in either default
+    pattern, but an instance can use ``{count}`` to say so ("monumentos — 34
+    monumentos portugueses to name").
+    """
+    values = {
+        "category": category_label(key),
+        "title": config.title,
+        "subtitle": config.subtitle,
+        "count": str(count),
+    }
+    return {
+        "title": _format(config.category_title, **values),
+        "description": shorten(
+            _format(
+                config.category_description,
+                description=site_description(config),
+                **values,
+            )
+        ),
+    }

{memi_engine-0.2.0 → memi_engine-0.3.0}/memi_engine/templates/about.html

@@ -1,15 +1,7 @@
 <!DOCTYPE html>
-<html lang="en">
+<html lang="{{ config.html_lang }}">
 <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>About - {{ config.title }}</title>
-    <link rel="icon" type="image/svg+xml" href="{{ url_for('favicon') }}?v={{ version }}">
-    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}?v={{ version }}">
-    <script>
-    var t = localStorage.getItem('memi-theme') || '{{ config.default_theme }}';
-    document.documentElement.dataset.theme = t;
-    </script>
+    {% include "head.html" %}
 </head>
 <body>
     <div class="theme-picker">

memi_engine-0.3.0/memi_engine/templates/head.html

@@ -0,0 +1,28 @@
+{# Shared <head>. `page` comes from app.py and is per-URL: the home page, the
+   about page and each category landing page each get their own title,
+   description and canonical. Without that they are one page repeated, because
+   which category you are looking at is otherwise only a JavaScript variable. #}
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ page.title }}</title>
+    <meta name="description" content="{{ page.description }}">
+    {# /food and /culture-food are the same category; the canonical picks one. #}
+    <link rel="canonical" href="{{ page.canonical }}">
+    <meta property="og:type" content="website">
+    <meta property="og:site_name" content="{{ config.title }}">
+    <meta property="og:title" content="{{ page.title }}">
+    <meta property="og:description" content="{{ page.description }}">
+    <meta property="og:url" content="{{ page.canonical }}">
+    {%- if page.og_image %}
+    <meta property="og:image" content="{{ page.og_image }}">
+    <meta name="twitter:card" content="summary_large_image">
+    {%- else %}
+    {# No image: the card still renders, just small. #}
+    <meta name="twitter:card" content="summary">
+    {%- endif %}
+    <link rel="icon" type="image/svg+xml" href="{{ url_for('favicon') }}?v={{ version }}">
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}?v={{ version }}">
+    <script>
+    var t = localStorage.getItem('memi-theme') || '{{ config.default_theme }}';
+    document.documentElement.dataset.theme = t;
+    </script>

{memi_engine-0.2.0 → memi_engine-0.3.0}/memi_engine/templates/index.html

@@ -1,15 +1,7 @@
 <!DOCTYPE html>
-<html lang="en">
+<html lang="{{ config.html_lang }}">
 <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{{ config.title }}</title>
-    <link rel="icon" type="image/svg+xml" href="{{ url_for('favicon') }}?v={{ version }}">
-    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}?v={{ version }}">
-    <script>
-    var t = localStorage.getItem('memi-theme') || '{{ config.default_theme }}';
-    document.documentElement.dataset.theme = t;
-    </script>
+    {% include "head.html" %}
 </head>
 <body>
     <div class="theme-picker">

{memi_engine-0.2.0 → memi_engine-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memi-engine"
-version = "0.2.0"
+version = "0.3.0"
 description = "Engine for building memi memory card game instances"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -32,7 +32,7 @@ server = ["gunicorn>=22"]
 dev = ["pytest>=8", "ruff>=0.6"]
 
 [project.urls]
-Homepage = "https://memi.click"
+Homepage = "https://memi.games"
 Repository = "https://github.com/filias/memi-engine"
 Issues = "https://github.com/filias/memi-engine/issues"