Flask-Themes2 2.0.0__py3-none-any.whl

flask_themes2/__init__.py

@@ -0,0 +1,666 @@
+"""
+Flask-Themes2
+=============
+
+This provides infrastructure for theming support in your Flask applications.
+It takes care of:
+
+- Loading themes
+- Rendering their templates
+- Serving their static media
+- Letting themes reference their templates and static media
+
+:copyright: 2013-2026 Chris Carter, <sh4nks>
+            2023 <ruby0b>
+            2021 Peter Justin
+            2012 Drew Lustro
+            2010 Matthew "LeafStorm" Frazier
+:license:   MIT/X11, see LICENSE for details
+"""
+
+from __future__ import annotations
+
+import itertools
+import os
+import re
+from collections.abc import Container
+
+# Yarg, here be pirates!
+from operator import attrgetter
+from typing import Any
+from typing import cast
+from typing import TYPE_CHECKING
+from typing import TypeVar
+
+from flask import abort
+from flask import Blueprint
+from flask import current_app
+from flask import json
+from flask import render_template
+from flask import send_from_directory
+from flask import url_for
+from jinja2 import pass_context
+from jinja2 import TemplateNotFound
+from jinja2.loaders import BaseLoader
+from jinja2.loaders import FileSystemLoader
+from werkzeug.utils import cached_property
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterable
+    from collections.abc import Iterator
+
+    from flask import Flask
+    from flask import Response
+    from jinja2 import Environment
+    from jinja2.runtime import Context
+
+    #: A theme loader is a callable that takes an app and returns an iterable
+    #: of the `Theme` instances it could find for it.
+    ThemeLoader = Callable[[Flask], Iterable["Theme"]]
+
+
+__version__ = "2.0.0"
+
+_T = TypeVar("_T")
+
+IDENTIFIER = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+
+
+def containable(i: Iterable[_T]) -> Container[_T]:
+    return i if isinstance(i, Container) else tuple(i)
+
+
+def starchain(i: Iterable[Iterable[_T]]) -> Iterator[_T]:
+    return itertools.chain(*i)
+
+
+def get_theme_manager(app: Flask | None = None) -> ThemeManager:
+    """Gets the application-specific ThemeManager.
+
+    :param app: The `~flask.Flask` application. Defaults to the current app.
+    """
+    if app is None:
+        app = current_app
+
+    if "themes" not in app.extensions:
+        raise RuntimeError("Flask-Themes2 not configured against current app")
+
+    manager: ThemeManager = app.extensions["themes"]
+    return manager
+
+
+def active_theme(ctx: Context) -> str:
+    if "_theme" in ctx:
+        return cast("str", ctx["_theme"])
+    elif ctx.name is not None and ctx.name.startswith("_themes/"):
+        return ctx.name[8:].split("/", 1)[0]
+    else:
+        raise RuntimeError("Could not find the active theme")
+
+
+@pass_context
+def global_theme_template(
+    ctx: Context, templatename: str, fallback: bool = True
+) -> str:
+    theme = active_theme(ctx)
+    if not fallback:
+        return get_theme_template_name(theme, templatename)
+    return get_theme_manager().get_template(theme, templatename)
+
+
+@pass_context
+def global_theme_static(ctx: Context, filename: str, external: bool = False) -> str:
+    theme = active_theme(ctx)
+    return static_file_url(theme, filename, external)
+
+
+@pass_context
+def global_theme_get_info(ctx: Context, attribute_name: str, fallback: Any = "") -> Any:
+    theme = get_theme(active_theme(ctx))
+    try:
+        info = getattr(theme, attribute_name)
+        if info is None:
+            raise AttributeError(f"Got None for getattr(theme, '{attribute_name}')")
+        return info
+    except AttributeError:
+        pass
+    return theme.options.get(attribute_name, fallback)
+
+
+def static_file_url(theme: Theme | str, filename: str, external: bool = False) -> str:
+    """
+    This is a shortcut for getting the URL of a static file in a theme.
+
+    :param theme: A `Theme` instance or identifier.
+    :param filename: The name of the file.
+    :param external: Whether the link should be external or not. Defaults to
+                     `False`.
+    """
+    if isinstance(theme, Theme):
+        theme = theme.identifier
+
+    # raises KeyError if the theme is not loaded
+    get_theme(theme)
+
+    if get_theme_manager().static_folder:
+        return url_for(
+            "_themes.static",
+            filename=theme + "/" + filename,
+            _external=external,
+        )
+    else:
+        return url_for(
+            "_themes.static",
+            themeid=theme,
+            filename=filename,
+            _external=external,
+        )
+
+
+def render_theme_template(
+    theme: Theme | str, template_name: str, _fallback: bool = True, **context: Any
+) -> str:
+    """
+    This renders a template from the given theme. For example::
+
+        return render_theme_template(g.user.theme, 'index.html', posts=posts)
+
+    If `_fallback` is True and the template does not exist within the theme,
+    it will fall back on trying to render the template using the application's
+    normal templates. (The "active theme" will still be set, though, so you
+    can try to extend or include other templates from the theme.)
+
+    :param theme: Either the identifier of the theme to use, or an actual
+                  `Theme` instance.
+    :param template_name: The name of the template to render.
+    :param _fallback: Whether to fall back to the default
+    """
+    if isinstance(theme, Theme):
+        theme = theme.identifier
+    context["_theme"] = theme
+    if not _fallback:
+        return render_template(get_theme_template_name(theme, template_name), **context)
+    return render_template(
+        get_theme_manager().get_template(theme, template_name), **context
+    )
+
+
+def get_theme_template_name(theme: Theme | str, template_name: str) -> str:
+    """
+    This returns the name under which the given theme's version of
+    ``template_name`` is exposed to Jinja, whether or not it exists.
+    """
+    if isinstance(theme, Theme):
+        theme = theme.identifier
+    return f"_themes/{theme}/{template_name}"
+
+
+### convenience #########################################################
+
+
+def get_theme(ident: str) -> Theme:
+    """
+    This gets the theme with the given identifier from the current app's
+    theme manager.
+
+    :param ident: The theme identifier.
+    """
+    return get_theme_manager().themes[ident]
+
+
+def get_themes_list() -> list[Theme]:
+    """
+    This returns a list of all the themes in the current app's theme manager,
+    sorted by identifier.
+    """
+    return list(get_theme_manager().list_themes())
+
+
+def static(themeid: str, filename: str) -> Response:
+    try:
+        theme = get_theme_manager().themes[themeid]
+    except KeyError:
+        abort(404)
+    return send_from_directory(theme.static_path, filename)
+
+
+def template_exists(templatename: str) -> bool:
+    """
+    This checks whether the current app can load a template with the given
+    name. The result is cached by the app's `ThemeManager` unless the Jinja
+    environment has ``auto_reload`` enabled.
+
+    :param templatename: The full template name, including any
+                         ``_themes/<identifier>/`` prefix.
+    """
+    return get_theme_manager().template_exists(templatename)
+
+
+def _loader_has_template(env: Environment, templatename: str) -> bool:
+    if env.loader is None:
+        return False
+    try:
+        env.loader.get_source(env, templatename)
+    except TemplateNotFound:
+        return False
+    return True
+
+
+### loaders #############################################################
+
+
+def list_folders(path: str | os.PathLike[str]) -> Iterator[str]:
+    """
+    This is a helper function that only returns the directories in a given
+    folder.
+
+    :param path: The path to list directories in.
+    """
+    return (
+        name for name in os.listdir(path) if os.path.isdir(os.path.join(path, name))
+    )
+
+
+def load_themes_from(path: str | os.PathLike[str]) -> Iterator[Theme]:
+    """
+    This is used by the default loaders. You give it a path, and it will find
+    valid themes and yield them one by one.
+
+    :param path: The path to search for themes in.
+    """
+    for basename in (b for b in list_folders(path) if IDENTIFIER.match(b)):
+        try:
+            t = Theme(os.path.join(path, basename))
+        except:  # noqa: E722, S110
+            pass
+        else:
+            if t.identifier == basename:
+                yield t
+
+
+def packaged_themes_loader(app: Flask) -> Iterable[Theme]:
+    """
+    This theme will find themes that are shipped with the application. It will
+    look in the application's root path for a ``themes`` directory - for
+    example, the ``someapp`` package can ship themes in the directory
+    ``someapp/themes/``.
+    """
+    themes_path = os.path.join(app.root_path, "themes")
+    if os.path.exists(themes_path):
+        return load_themes_from(themes_path)
+    else:
+        return ()
+
+
+def theme_paths_loader(app: Flask) -> Iterable[Theme]:
+    """
+    This checks the app's `THEME_PATHS` configuration variable to find
+    directories that contain themes. The theme's identifier must match the
+    name of its directory.
+    """
+    theme_paths: Iterable[str | os.PathLike[str]] = app.config.get("THEME_PATHS", ())
+
+    if isinstance(theme_paths, str):
+        theme_paths = [p.strip() for p in theme_paths.split(";")]
+    return starchain(load_themes_from(path) for path in theme_paths)
+
+
+class ThemeTemplateLoader(BaseLoader):
+    """
+    This is a template loader that loads templates from the current app's
+    loaded themes.
+    """
+
+    def __init__(self, as_blueprint: bool = False) -> None:
+        self.as_blueprint = as_blueprint
+        BaseLoader.__init__(self)
+
+    def get_source(
+        self, environment: Environment, template: str
+    ) -> tuple[str, str | None, Callable[[], bool] | None]:
+        if self.as_blueprint and template.startswith("_themes/"):
+            template = template[8:]
+        try:
+            themename, templatename = template.split("/", 1)
+            theme = get_theme_manager().themes[themename]
+        except (ValueError, KeyError):
+            raise TemplateNotFound(template) from None
+        try:
+            return theme.jinja_loader.get_source(environment, templatename)
+        except TemplateNotFound:
+            raise TemplateNotFound(template) from None
+
+    def list_templates(self) -> list[str]:
+        res: list[str] = []
+        fmt = "_themes/%s/%s"
+        for ident, theme in get_theme_manager().themes.items():
+            res.extend((fmt % (ident, t)) for t in theme.jinja_loader.list_templates())
+        return res
+
+
+#########################################################################
+
+
+class _ThemesBlueprint(Blueprint):
+    @cached_property
+    def jinja_loader(self) -> BaseLoader:
+        return ThemeTemplateLoader(True)
+
+
+themes_blueprint = _ThemesBlueprint("_themes", __name__)
+
+
+class Themes:
+    """
+    This is the main class you will use to interact
+    with Flask-Themes2 on your app.
+
+    It really only implements the bare minimum, the rest
+    is passed through to other methods and classes.
+    """
+
+    def __init__(self, app: Flask | None = None, **kwargs: Any) -> None:
+        """
+        If given an app, this will simply call init_themes,
+        and pass through all kwargs to init_themes,
+        making it super easy.
+
+        :param app: the `~flask.Flask` instance to setup themes for.
+        :param kwargs: keyword args to pass through to init_themes
+        """
+        self._app: Flask | None = app
+        if app is not None:
+            self.init_themes(app, **kwargs)
+
+    def init_themes(
+        self,
+        app: Flask,
+        loaders: Iterable[ThemeLoader] | None = None,
+        app_identifier: str | None = None,
+        manager_cls: type[ThemeManager] | None = None,
+        theme_url_prefix: str = "/_themes",
+        static_folder: str | None = None,
+    ) -> None:
+        """This sets up the theme infrastructure by adding a `ThemeManager`
+        to the given app and registering the module/blueprint containing the
+        views and templates needed.
+
+        :param app: The `~flask.Flask` instance to set up themes for.
+        :param loaders: An iterable of loaders to use. It defaults to
+                        `packaged_themes_loader` and `theme_paths_loader`.
+        :param app_identifier: The application identifier to use. If not given,
+                               it defaults to the app's import name.
+        :param manager_cls: If you need a custom manager class, you can pass it
+                            in here.
+        :param theme_url_prefix: The prefix to use for the URLs on the themes
+                                 module. (Defaults to ``/_themes``.)
+        """
+        if app_identifier is None:
+            app_identifier = app.import_name
+        if manager_cls is None:
+            manager_cls = ThemeManager
+        manager_cls(app, app_identifier, loaders=loaders, static_folder=static_folder)
+
+        app.jinja_env.globals["theme"] = global_theme_template
+        app.jinja_env.globals["theme_static"] = global_theme_static
+        app.jinja_env.globals["theme_get_info"] = global_theme_get_info
+
+        if static_folder:
+            themes_blueprint.static_folder = static_folder
+            themes_blueprint.static_url_path = (
+                f"{app.static_url_path or ''}{theme_url_prefix}"
+            )
+        else:
+            themes_blueprint.url_prefix = theme_url_prefix
+            themes_blueprint.add_url_rule(
+                "/<themeid>/<path:filename>", "static", view_func=static
+            )
+
+        app.register_blueprint(themes_blueprint)
+
+
+class ThemeManager:
+    """
+    This is responsible for loading and storing all the themes for an
+    application. Calling `refresh` will cause it to invoke all of the theme
+    loaders.
+
+    A theme loader is simply a callable that takes an app and returns an
+    iterable of `Theme` instances. You can implement your own loaders if your
+    app has another way to load themes.
+
+    :param app: The app to bind to. (Each instance is only usable for one
+                app.)
+    :param app_identifier: The value that the info.json's `application` key
+                           is required to have. If you require a more complex
+                           check, you can subclass and override the
+                           `valid_app_id` method.
+    :param loaders: An iterable of loaders to use. The defaults are
+                    `packaged_themes_loader` and `theme_paths_loader`, in that
+                    order.
+    """
+
+    def __init__(
+        self,
+        app: Flask,
+        app_identifier: str,
+        loaders: Iterable[ThemeLoader] | None = None,
+        static_folder: str | None = None,
+    ) -> None:
+        self.bind_app(app)
+        self.app_identifier = app_identifier
+        self.static_folder = static_folder
+
+        self._themes: dict[str, Theme] | None = None
+        self._template_exists_cache: dict[str, bool] = {}
+
+        #: This is a list of the loaders that will be used to load the themes.
+        self.loaders: list[ThemeLoader] = []
+        if loaders:
+            self.loaders.extend(loaders)
+        else:
+            self.loaders.extend((packaged_themes_loader, theme_paths_loader))
+
+    @property
+    def themes(self) -> dict[str, Theme]:
+        """
+        This is a dictionary of all the themes that have been loaded. The keys
+        are the identifiers and the values are `Theme` objects.
+        """
+        themes = self._themes
+        if themes is None:
+            themes = self._themes = self._load_themes()
+        return themes
+
+    def list_themes(self) -> list[Theme]:
+        """
+        This yields all the `Theme` objects, in sorted order.
+        """
+        return sorted(self.themes.values(), key=attrgetter("identifier"))
+
+    def bind_app(self, app: Flask) -> None:
+        """
+        If an app wasn't bound when the manager was created, this will bind
+        it. The app must be bound for the loaders to work.
+
+        :param app: A `~flask.Flask` instance.
+        """
+        self.app = app
+        app.extensions["themes"] = self
+
+        # kept for backwards compatibility, use get_theme_manager() instead
+        app.theme_manager = self  # type: ignore[attr-defined]
+
+    def valid_app_id(self, app_identifier: str) -> bool:
+        """
+        This checks whether the application identifier given will work with
+        this application. The default implementation checks whether the given
+        identifier matches the one given at initialization.
+
+        :param app_identifier: The application identifier to check.
+        """
+        return self.app_identifier == app_identifier
+
+    def refresh(self) -> None:
+        """
+        This loads all of the themes into the `themes` dictionary. The loaders
+        are invoked in the order they are given, so later themes will override
+        earlier ones. Any invalid themes found (for example, if the
+        application identifier is incorrect) will be skipped.
+        """
+        self._themes = self._load_themes()
+        self._template_exists_cache.clear()
+
+    def template_exists(self, templatename: str) -> bool:
+        """
+        This checks whether the bound app can load a template with the given
+        name. Lookups are cached, because Jinja only caches templates it
+        found and every miss would otherwise walk the app's and every
+        blueprint's loader. The cache is bypassed while the Jinja environment
+        has ``auto_reload`` enabled, so new theme overrides are picked up in
+        debug mode, and cleared by `refresh`.
+
+        :param templatename: The full template name, including any
+                             ``_themes/<identifier>/`` prefix.
+        """
+        env = self.app.jinja_env
+        if env.auto_reload:
+            return _loader_has_template(env, templatename)
+        cache = self._template_exists_cache
+        try:
+            return cache[templatename]
+        except KeyError:
+            exists = cache[templatename] = _loader_has_template(env, templatename)
+            return exists
+
+    def get_template(self, theme: Theme | str, template_name: str) -> str:
+        """
+        This returns the name to render for ``template_name`` in the given
+        theme: the theme's own version if it has one, otherwise the
+        application's ``template_name``.
+
+        :param theme: Either the identifier of the theme or a `Theme`.
+        :param template_name: The name of the template to look up.
+        """
+        themed_name = get_theme_template_name(theme, template_name)
+        if self.template_exists(themed_name):
+            return themed_name
+        return template_name
+
+    def _load_themes(self) -> dict[str, Theme]:
+        themes: dict[str, Theme] = {}
+        for theme in starchain(ldr(self.app) for ldr in self.loaders):
+            if self.valid_app_id(theme.application):
+                themes[theme.identifier] = theme
+        return themes
+
+
+class Theme:
+    """
+    This contains a theme's metadata.
+
+    :param path: The path to the theme directory.
+    """
+
+    def __init__(self, path: str | os.PathLike[str]) -> None:
+        #: The theme's root path. All the files in the theme are under this
+        #: path.
+        self.path = os.path.abspath(path)
+
+        with open(os.path.join(self.path, "info.json")) as fd:
+            i: dict[str, Any] = json.load(fd)
+
+        #: The raw contents of the theme's info.json.
+        self.info = i
+
+        #: The theme's name, as given in info.json. This is the human
+        #: readable name.
+        self.name: str = i["name"]
+
+        #: The application identifier given in the theme's info.json. Your
+        #: application will probably want to validate it.
+        self.application: str = i["application"]
+
+        #: The theme's identifier. This is an actual Python identifier,
+        #: and in most situations should match the name of the directory the
+        #: theme is in.
+        self.identifier: str = i["identifier"]
+
+        #: The human readable description. This is the default (English)
+        #: version.
+        self.description: str | None = i.get("description")
+
+        #: This is a dictionary of localized versions of the description.
+        #: The language codes are all lowercase, and the ``en`` key is
+        #: preloaded with the base description.
+        self.localized_desc: dict[str, str | None] = {
+            k.split("_", 1)[1].lower(): v
+            for k, v in i.items()
+            if k.startswith("description_")
+        }
+        self.localized_desc.setdefault("en", self.description)
+
+        #: The author's name, as given in info.json. This may or may not
+        #: include their email, so it's best just to display it as-is.
+        self.author: str = i["author"]
+
+        #: A short phrase describing the license, like "GPL", "BSD", "Public
+        #: Domain", or "Creative Commons BY-SA 3.0".
+        self.license: str | None = i.get("license")
+
+        #: A URL pointing to the license text online.
+        self.license_url: str | None = i.get("license_url")
+
+        #: The URL to the theme's or author's Web site.
+        self.website: str | None = i.get("website")
+
+        #: The theme's preview image, within the static folder.
+        self.preview: str | None = i.get("preview")
+
+        #: The theme's doctype. This can be ``html4``, ``html5``, or ``xhtml``
+        #: with html5 being the default if not specified.
+        self.doctype: str = i.get("doctype", "html5")
+
+        #: The theme's version string.
+        self.version: str | None = i.get("version")
+
+        #: Any additional options. These are entirely application-specific,
+        #: and may determine other aspects of the application's behavior.
+        self.options: dict[str, Any] = i.get("options", {})
+
+    @cached_property
+    def static_path(self) -> str:
+        """
+        The absolute path to the theme's static files directory.
+        """
+        return os.path.join(self.path, "static")
+
+    @cached_property
+    def templates_path(self) -> str:
+        """
+        The absolute path to the theme's templates directory.
+        """
+        return os.path.join(self.path, "templates")
+
+    @cached_property
+    def license_text(self) -> str | None:
+        """
+        The contents of the theme's license.txt file, if it exists. This is
+        used to display the full license text if necessary. (It is `None` if
+        there was not a license.txt.)
+        """
+        lt_path = os.path.join(self.path, "license.txt")
+        if os.path.exists(lt_path):
+            with open(lt_path) as fd:
+                return fd.read()
+        else:
+            return None
+
+    @cached_property
+    def jinja_loader(self) -> FileSystemLoader:
+        """
+        This is a Jinja2 template loader that loads templates from the theme's
+        ``templates`` directory.
+        """
+        return FileSystemLoader(self.templates_path)

flask_themes2-2.0.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.5
+Name: Flask-Themes2
+Version: 2.0.0
+Summary: Provides infrastructure for theming Flask applications
+Author-email: Chris Carter <chris@gibsonsec.org>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: flask>=2.0
+Project-URL: Documentation, https://flask-themes2.readthedocs.io
+Project-URL: Source, https://github.com/sysr-q/flask-themes2
+Import-Name: flask_themes2
+
+# Flask-Themes2
+
+[docs]: https://flask-themes2.readthedocs.io/en/latest/
+[GitHub]: https://github.com/sysr-q/flask-themes2
+
+Flask-Themes2 is a fork of Spirits, which is in turn a fork of Flask-Themes.
+
+- [Flask-Themes2](https://github.com/sysr-q/flask-themes2) maintained by Chris Carter et al.
+- [Spirits](https://github.com/drewlustro/spirits) maintained by Drew Lustro
+- [Flask-Themes](https://bitbucket.org/leafstorm/flask-themes) by Matthew "LeafStorm" Frazier
+- Many more contributors to this fork and all others! It wouldn't be this good without you.
+
+This provides infrastructure for themes in Flask >= 2.0.
+
+> [!NOTE]
+> Flask-Themes2 2.x requires Python 3.11 or newer.
+
+
+## Installation
+
+To install normally:
+```sh
+$ pip install flask-themes2
+```
+
+To install the development version from the latest commit on `master`:
+```sh
+$ pip install "Flask-Themes2 @ git+https://github.com/sysr-q/flask-themes2.git@master"
+```
+
+## Documentation
+
+The documentation is on the Flask-Themes2 [docs].
+
+## Development
+
+If you're interested in helping, the source is available on [GitHub], feel free to contribute.
+
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then clone
+the repository and install the project and development dependencies:
+
+```sh
+git clone https://github.com/sysr-q/flask-themes2.git
+cd flask-themes2
+uv sync --locked
+```
+
+Run the tests on the development Python version:
+
+```sh
+uv run --locked pytest
+```
+
+Run the full test matrix (Python 3.11–3.14), formatting and lint checks,
+type checks, and documentation build:
+
+```sh
+uv python install 3.11 3.12 3.13 3.14
+uv run --locked tox
+```
+
+You can also run individual checks, for example:
+
+```sh
+uv run --locked tox run -e py3.11,typing,docs
+uv run --locked pre-commit run --all-files
+```
+
+## Releases
+
+Update `__version__` in `src/flask_themes2/__init__.py`, commit the release
+changes, and push them to `master`. Release tags use the plain `MAJOR.MINOR.PATCH`
+format, for example `2.0.0`, without a `v` prefix or prerelease suffix.
+
+Pushing a release tag triggers the publish workflow. It checks that the tag
+matches `__version__`, runs the full test matrix and other checks, and builds and
+validates the distributions before publishing to PyPI through the `publish`
+environment. After successful publication, it creates a draft GitHub release
+for you to add release notes and publish; pushing commits to `master` alone
+does not publish a release.
+
+

flask_themes2-2.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+flask_themes2/__init__.py,sha256=E_YC5QdLWzVfHivtd7OYvONHy-WVmLBdnvvmScZemK8,22816
+flask_themes2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flask_themes2-2.0.0.dist-info/licenses/LICENSE,sha256=0lVBI2sEJ_-qvXPTGcJ78bw8XAkbG_oy6yGpscO5juo,1146
+flask_themes2-2.0.0.dist-info/WHEEL,sha256=lqN8jXt_QloFOGcx9kStvWbryhfEXoI2F2z-YURm350,81
+flask_themes2-2.0.0.dist-info/METADATA,sha256=Ymx6gC7aIP3L2gR-GNpV_gN_ckVAYReEzjen7ua3gdY,3295
+flask_themes2-2.0.0.dist-info/RECORD,,

flask_themes2-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 4.1.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flask_themes2-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2013-2021 Chris Carter, 2021 Peter Justin,
+              2012 Drew Lustro, 2010 Matthew "LeafStorm" Frazier
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.