djangocms-render-context 1.0.0__py3-none-any.whl

djangocms_render_context/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

djangocms_render_context/cache.py

@@ -0,0 +1,2 @@
+def get_cache_key(identifier: int) -> str:
+    return f"djangocms_render_context_url_{identifier}"

djangocms_render_context/cms_plugins.py

@@ -0,0 +1,50 @@
+from cms.models.placeholdermodel import Placeholder
+from cms.plugin_base import CMSPluginBase
+from cms.plugin_pool import plugin_pool
+from django.template import Template
+from django.template.backends.django import Template as DjangoTemplate
+from django.template.loader import get_template
+from django.utils.translation import gettext_lazy as _
+
+from .forms import RenderContextForm
+from .models import RenderContext
+from .utils import create_html
+
+
+@plugin_pool.register_plugin
+class RenderContextPlugin(CMSPluginBase):
+    model = RenderContext
+    form = RenderContextForm
+    name = _("Render Context Plugin")
+    fieldsets = [
+        (
+            _("Sources"),
+            {
+                "fields": (
+                    "context",
+                    "file",
+                    (
+                        "source",
+                        "cached",
+                    ),
+                ),
+            },
+        ),
+        (
+            _("Templates"),
+            {
+                "classes": ["collapse"],
+                "fields": (
+                    "template",
+                    "template_list",
+                ),
+            },
+        ),
+    ]
+
+    def get_render_template(self, context: dict, instance: RenderContext, placeholder: Placeholder) -> DjangoTemplate:
+        context["data"] = instance.get_data()
+        if instance.template_list and not instance.template:
+            return get_template(instance.template_list)
+        tmpl = Template(instance.template if instance.template else create_html(context["data"]))
+        return DjangoTemplate(tmpl, tmpl)

djangocms_render_context/encoders.py

@@ -0,0 +1,8 @@
+from django.core.serializers.json import DjangoJSONEncoder
+
+
+class PrettyJsonEncoder(DjangoJSONEncoder):
+    def __init__(self, *args, **kwargs):
+        kwargs["indent"] = 2
+        kwargs["sort_keys"] = False
+        super().__init__(*args, **kwargs)

djangocms_render_context/exceptions.py

@@ -0,0 +1,2 @@
+class SourceParseFailure(Exception):
+    """Source parse failure."""

djangocms_render_context/forms.py

@@ -0,0 +1,95 @@
+from collections.abc import Callable
+from typing import Union
+
+from django import forms
+from django.conf import settings
+from django.core.cache import cache
+from django.core.exceptions import ValidationError
+from django.forms import ALL_FIELDS, ModelForm
+from django.template import Context, Template, TemplateDoesNotExist
+from django.template.exceptions import TemplateSyntaxError
+from django.template.loader import get_template
+from django.utils.translation import gettext_lazy as _
+from filer.models.filemodels import File
+
+from .cache import get_cache_key
+from .exceptions import SourceParseFailure
+from .loaders import SUPPORTED_FILE_TYPES, get_data_from_file, get_data_from_url
+
+TEMPLATES = (("", ""),)
+
+sourceType = Union[str, File]  # noqa: UP007
+
+
+class RenderContextForm(ModelForm):
+    """Render Context Form."""
+
+    template_list = forms.ChoiceField(
+        label=_("Template list"),
+        required=False,
+        choices=getattr(settings, "DJANGOCMS_RENDER_CONTEXT_TEMPLATES", TEMPLATES),
+        help_text=_("List of templates. If Template is specified, the template set in the list will not be used."),
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["file"].help_text += " " + _("Supported formats are:") + " " + ", ".join(SUPPORTED_FILE_TYPES)
+
+    def clean_template_list(self) -> None:
+        if self.cleaned_data["template_list"]:
+            try:
+                get_template(self.cleaned_data["template_list"])
+            except TemplateSyntaxError as error:
+                raise ValidationError(error) from error
+            except TemplateDoesNotExist as error:
+                raise ValidationError(f'Template "{error}" does not exist.') from error
+        return self.cleaned_data["template_list"]
+
+    def check_value(self, name: str, value: sourceType, loader: Callable) -> Context:
+        try:
+            return Context(loader(value))
+        except SourceParseFailure as error:
+            self.add_error(name, error)
+
+    def check_context(self, cleaned_data: dict) -> Context:
+        context = Context({})
+        if cleaned_data["context"]:
+            context = Context(cleaned_data["context"])
+        elif cleaned_data["file"]:
+            context = self.check_value("file", cleaned_data["file"], get_data_from_file)
+        elif cleaned_data["source"]:
+            context = self.check_value("source", cleaned_data["source"], get_data_from_url)
+        if context is None:
+            self.add_error(ALL_FIELDS, "Failed to set context.")
+            context = Context({})
+        return context
+
+    def check_template(self, cleaned_data: dict, context: Context) -> None:
+        template = None
+        field_name = ALL_FIELDS
+        if cleaned_data["template"]:
+            field_name = "template"
+            try:
+                template = Template(cleaned_data["template"])
+            except TemplateSyntaxError as error:
+                self.add_error("template", error)
+        elif cleaned_data["template_list"]:
+            field_name = "template_list"
+            template = get_template(cleaned_data["template_list"]).template
+        if template:
+            try:
+                template.render(context)
+            except (TemplateDoesNotExist, TemplateSyntaxError) as error:
+                self.add_error(field_name, error)
+
+    def clean(self) -> None:
+        """Clean form."""
+        cleaned_data = super().clean()
+        if self.is_valid():
+            context = self.check_context(cleaned_data)
+            self.check_template(cleaned_data, context)
+
+    def save(self, *args, **kwargs):
+        if self.instance.pk:
+            cache.delete(get_cache_key(self.instance.pk))
+        return super().save(*args, **kwargs)

djangocms_render_context/loaders.py

@@ -0,0 +1,214 @@
+import csv
+import json
+import xml.etree.ElementTree as ET
+import zipfile
+from io import BytesIO, StringIO
+from mimetypes import guess_type
+from typing import Union, cast
+
+import requests
+import yaml
+from django.conf import settings
+from django.core.cache import cache
+from django.utils.translation import gettext_lazy as _
+from filer.models.filemodels import File
+
+# Use the C (faster) implementation if possible
+try:
+    from yaml import CSafeLoader as SafeLoader
+except ImportError:  # pragma: no cover
+    from yaml import SafeLoader  # type: ignore
+
+from .cache import get_cache_key
+from .exceptions import SourceParseFailure
+
+dataType = Union[dict, list]  # noqa: UP007
+valueType = Union[str, list]  # noqa: UP007
+cellType = Union[dict, str, list]  # noqa: UP007
+nodeTextType = Union[str, None]  # noqa: UP007
+payloadType = Union[str, dict]  # noqa: UP007
+
+
+def get_mime_type_message(mime_type: nodeTextType) -> str:
+    return (
+        _("Unsupported file mime type: ")
+        + str(mime_type)
+        + ". "
+        + _("Only allowed are:")
+        + " "
+        + ", ".join(SUPPORTED_FILE_TYPES)
+        + "."
+    )
+
+
+def get_data_from_file(source: File) -> dataType:
+    if source.mime_type not in LOADERS:
+        raise SourceParseFailure(get_mime_type_message(source.mime_type))
+    return LOADERS[source.mime_type](source.file.read())
+
+
+def load_json(content: bytes) -> dataType:
+    try:
+        return json.load(BytesIO(content))
+    except json.decoder.JSONDecodeError as err:
+        raise SourceParseFailure(err) from err
+
+
+def load_yaml(content: bytes) -> dataType:
+    try:
+        return yaml.load(content, Loader=SafeLoader)
+    except yaml.YAMLError as err:
+        raise SourceParseFailure(err) from err
+
+
+def load_csv(content: bytes) -> list:
+    try:
+        body = content.decode("utf8")
+    except UnicodeDecodeError as err:
+        raise SourceParseFailure(err) from err
+    reader = csv.reader(StringIO(body))
+    try:
+        return list(reader)
+    except csv.Error as err:
+        raise SourceParseFailure(err) from err
+
+
+def load_xml(content: bytes) -> dataType:
+    data = []
+    try:
+        doc = ET.parse(BytesIO(content))
+    except ET.ParseError as err:
+        raise SourceParseFailure(err) from err
+    root = doc.getroot()
+    for row in root:
+        data.append([column.text for column in row])
+    return data
+
+
+def load_spreadsheet(content: bytes) -> dataType:
+    handle = None
+    try:
+        handle = zipfile.ZipFile(BytesIO(content))
+        payload = handle.read("content.xml")
+    except (zipfile.BadZipFile, KeyError) as err:
+        raise SourceParseFailure(err) from err
+    finally:
+        if handle is None:
+            pass
+        else:
+            handle.close()
+    try:
+        doc = ET.parse(BytesIO(payload))
+    except ET.ParseError as err:
+        raise SourceParseFailure(err) from err
+    return pase_data(cast(ET.ElementTree, doc))
+
+
+def pase_data(doc: ET.ElementTree) -> dataType:
+    data: list[list[cellType]] = []
+    ns = {
+        "table": "urn:oasis:names:tc:opendocument:xmlns:table:1.0",
+        "text": "urn:oasis:names:tc:opendocument:xmlns:text:1.0",
+        "xlink": "http://www.w3.org/1999/xlink",
+    }
+    max_gap = getattr(settings, "DJANGOCMS_RENDER_CONTEXT_ODS_MAX_GAP", 51)
+    root = doc.getroot()
+    if root is None:
+        return data
+    table = root.find(".//table:table", ns)
+    if table is not None:
+        for row in table.findall("table:table-row", ns):
+            repeated = row.get(qname(ns, "table:number-rows-repeated"))
+            if repeated is not None:
+                offset = int(repeated) - 1
+                if offset < max_gap:
+                    data.extend([] * offset)
+            data.append(parse_cells(ns, max_gap, row))
+    while data and data[-1] == [""]:
+        data.pop()
+    return data
+
+
+def parse_cells(ns: dict[str, str], max_gap: int, row: ET.Element) -> list[cellType]:
+    line: list[cellType] = []
+    for cell in row.findall("table:table-cell", ns):
+        repeated = cell.get(qname(ns, "table:number-columns-repeated"))
+        if repeated is not None:
+            offset = int(repeated) - 1
+            if offset < max_gap:
+                line.extend([""] * offset)
+        payload: list[payloadType] = []
+        for text in cell.findall("text:p", ns):
+            if text.text is not None:
+                payload.append({"p": text.text})
+            for link in text.findall("text:a", ns):
+                href = link.get(qname(ns, "xlink:href"))
+                payload.append({"href": href, "text": none_to_str(link.text)})
+        if len(payload) == 1:
+            payload = payload[0]  # type: ignore
+            if "p" in payload:
+                payload = payload["p"]  # type: ignore
+        if payload == []:
+            payload = ""  # type: ignore
+        line.append(payload)
+    return line
+
+
+def none_to_str(value: nodeTextType) -> str:
+    return "" if value is None else str(value)
+
+
+def qname(ns: dict[str, str], prefix_and_name: str) -> str:
+    """Create qualified xml element name."""
+    parts = prefix_and_name.split(":", 1)
+    prefix, name = parts
+    return str(ET.QName(ns[prefix], name))
+
+
+def load_source(url: str):
+    """Load data from the source."""
+    timeout = getattr(settings, "DJANGOCMS_RENDER_CONTEXT_LOAD_TIMEOUT", 6)
+    verify = getattr(settings, "DJANGOCMS_RENDER_CONTEXT_VERIFY", True)
+    response = requests.get(url, timeout=timeout, verify=verify)
+    response.raise_for_status()
+    return response
+
+
+def get_data_from_url(source: str) -> dataType:
+    data: dataType = []
+    try:
+        response = load_source(source)
+    except requests.RequestException as err:
+        raise SourceParseFailure(err) from err
+    content_type = response.headers.get("Content-Type")
+    if content_type not in LOADERS:
+        content_type = guess_type(source)[0]
+    if content_type not in LOADERS:
+        raise SourceParseFailure(get_mime_type_message(content_type))
+    try:
+        data = LOADERS[content_type](response.content)
+    except SourceParseFailure as err:
+        raise SourceParseFailure(_("Resource parsing failed.")) from err
+    return data
+
+
+def get_cached_data_from_url(identifier: int, source: str, timeout: int) -> dataType:
+    key = get_cache_key(identifier)
+    if timeout:
+        data = cache.get(key)
+        if data is None:
+            data = get_data_from_url(source)
+            cache.set(key, data, timeout * 60)
+    else:
+        data = get_data_from_url(source)
+    return data
+
+
+SUPPORTED_FILE_TYPES = ("csv", "json", "yaml", "xml", "ods")
+LOADERS = {
+    "text/csv": load_csv,
+    "application/json": load_json,
+    "application/yaml": load_yaml,
+    "application/xml": load_xml,
+    "application/vnd.oasis.opendocument.spreadsheet": load_spreadsheet,
+}

djangocms_render_context/locale/cs/LC_MESSAGES/django.po

@@ -0,0 +1,107 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-12-11 13:17+0100\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: Zdeněk Böhm <zdenek.bohm@nic.cz>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: cs\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\n"
+
+msgid ""
+"Context data file. If Data is specified for the context, the source file is "
+"not used even though it is specified."
+msgstr ""
+"Soubor se zdrojovými daty. Pokud jsou zadána Data pro kontext, tak se "
+"zdrojový soubor nepoužije i přesto, že je zadán."
+
+msgid ""
+"Context data in JSON format. They take precedence over the source file and "
+"source URL."
+msgstr ""
+"Data pro kontext ve formátu JSON. Mají přednost před zdrojovým souborem a "
+"URL zdroje."
+
+msgid "Data for context"
+msgstr "Data pro kontext"
+
+msgid "Data not entered."
+msgstr "Data nejsou zadána."
+
+msgid ""
+"Django template for the context. It takes precedence over the template "
+"selected from the list."
+msgstr "Django šablona. Má přednost přes šablonou vybranou ze seznamu."
+
+msgid "Download period from source URL"
+msgstr "Perioda stahování ze URL zdroje"
+
+msgid ""
+"List of templates. If Template is specified, the template set in the list "
+"will not be used."
+msgstr ""
+"Seznam šablon. Pokud je zadána Šablona, tak se šablona nastavená v seznamu "
+"nepoužije."
+
+msgid "No template."
+msgstr "Žádná šablona."
+
+msgid "Only allowed are:"
+msgstr "Povolené jsou jen:"
+
+msgid "Render Context Plugin"
+msgstr "Vykreslování kontextu"
+
+msgid "Resource parsing failed."
+msgstr "Parsování zdroje selhalo."
+
+msgid "Source URL"
+msgstr "URL zdroje"
+
+msgid "Source file"
+msgstr "Zdrojový soubor."
+
+msgid "Sources"
+msgstr "Zdroje"
+
+msgid "Supported formats are:"
+msgstr "Podporované formáty jsou:"
+
+msgid "Template"
+msgstr "Šablona"
+
+msgid "Template list"
+msgstr "Seznam šablon"
+
+msgid "Templates"
+msgstr "Šablony"
+
+msgid ""
+"The URL of the source from which the data will be downloaded. If Data for "
+"Context or Source File is specified, the source URL is not used even though "
+"it is specified."
+msgstr ""
+"URL zdroje, ze kterého se data budou stahovat. Pokud jsou zadána Data pro "
+"kontext nebo Zdrojový soubor, tak se URL zdroje nepoužije i přesto, že je "
+"zadáno."
+
+msgid ""
+"The time in minutes during which data will not be retrieved from the Source "
+"URL, but will remain in the cache. If set to zero, data from the source URL "
+"is not cached, but is loaded every time."
+msgstr ""
+"Doba v minutách, po kterou se data nebudou načítat z URL zdroje, ale "
+"zůstanou ponechána v cache. Je-li nastavena nula, tak se data z URL zdroje "
+"do cache neukládají, ale načítají se pokaždé."
+
+msgid "Unsupported file mime type: "
+msgstr "Nepodporovaný mime typ souboru: "

djangocms_render_context/migrations/0001_initial.py

@@ -0,0 +1,96 @@
+# Generated by Django 5.2.8 on 2025-12-10 09:02
+
+import django.db.models.deletion
+import djangocms_render_context.encoders
+import filer.fields.file
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("cms", "0034_remove_pagecontent_placeholders"),
+        ("filer", "0017_image__transparent"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="RenderContext",
+            fields=[
+                (
+                    "cmsplugin_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        related_name="%(app_label)s_%(class)s",
+                        serialize=False,
+                        to="cms.cmsplugin",
+                    ),
+                ),
+                (
+                    "context",
+                    models.JSONField(
+                        blank=True,
+                        encoder=djangocms_render_context.encoders.PrettyJsonEncoder,
+                        help_text="Context data in JSON format. They take precedence over the source file and source URL.",
+                        null=True,
+                        verbose_name="Data for context",
+                    ),
+                ),
+                (
+                    "source",
+                    models.URLField(
+                        blank=True,
+                        help_text="The URL of the source from which the data will be downloaded. If Data for Context or Source File is specified, "
+                                  "the source URL is not used even though it is specified.",
+                        null=True,
+                        verbose_name="Source URL",
+                    ),
+                ),
+                (
+                    "cached",
+                    models.PositiveSmallIntegerField(
+                        default=5,
+                        help_text="The time in minutes during which data will not be retrieved from the Source URL, but will remain in the cache. "
+                                  "If set to zero, data from the source URL is not cached, but is loaded every time.",
+                        verbose_name="Download period from source URL",
+                    ),
+                ),
+                (
+                    "template",
+                    models.TextField(
+                        blank=True,
+                        help_text="Django template for the context. It takes precedence over the template selected from the list.",
+                        null=True,
+                        verbose_name="Template",
+                    ),
+                ),
+                (
+                    "template_list",
+                    models.CharField(
+                        blank=True,
+                        help_text="List of templates. If Template is specified, the template set in the list will not be used.",
+                        max_length=255,
+                        null=True,
+                        verbose_name="Template list",
+                    ),
+                ),
+                (
+                    "file",
+                    filer.fields.file.FilerFileField(
+                        blank=True,
+                        help_text="Context data file. If Data is specified for the context, the source file is not used even though it is specified.",
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="filer.file",
+                        verbose_name="Source file",
+                    ),
+                ),
+            ],
+            bases=("cms.cmsplugin",),
+        ),
+    ]

djangocms_render_context/models.py

@@ -0,0 +1,96 @@
+import logging
+
+from cms.models.pluginmodel import CMSPlugin
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from filer.fields.file import FilerFileField
+
+from .encoders import PrettyJsonEncoder
+from .exceptions import SourceParseFailure
+from .loaders import get_cached_data_from_url, get_data_from_file
+
+LOGGER = logging.getLogger(__name__)
+
+
+class RenderContext(CMSPlugin):
+    context = models.JSONField(
+        verbose_name=_("Data for context"),
+        null=True,
+        blank=True,
+        encoder=PrettyJsonEncoder,
+        help_text=_("Context data in JSON format. They take precedence over the source file and source URL."),
+    )
+    file = FilerFileField(
+        verbose_name=_("Source file"),
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        help_text=_(
+            "Context data file. If Data is specified for the context, the source file is not used even "
+            "though it is specified."
+        ),
+    )
+    source = models.URLField(
+        verbose_name=_("Source URL"),
+        null=True,
+        blank=True,
+        help_text=_(
+            "The URL of the source from which the data will be downloaded. If Data for Context or Source File"
+            " is specified, the source URL is not used even though it is specified."
+        ),
+    )
+    cached = models.PositiveSmallIntegerField(
+        verbose_name=_("Download period from source URL"),
+        default=5,
+        help_text=_(
+            "The time in minutes during which data will not be retrieved from the Source URL, but will remain "
+            "in the cache. If set to zero, data from the source URL is not cached, but is loaded every time."
+        ),
+    )
+
+    template = models.TextField(
+        verbose_name=_("Template"),
+        null=True,
+        blank=True,
+        help_text=_("Django template for the context. It takes precedence over the template selected from the list."),
+    )
+    template_list = models.CharField(
+        verbose_name=_("Template list"),
+        null=True,
+        blank=True,
+        max_length=255,
+        help_text=_("List of templates. If Template is specified, the template set in the list will not be used."),
+    )
+
+    def __str__(self):
+        text = []
+        if self.context:
+            text.append(self._meta.get_field("context").verbose_name)
+        elif self.file:
+            text.append(self._meta.get_field("file").verbose_name)
+        elif self.source:
+            text.append(self._meta.get_field("source").verbose_name)
+        else:
+            text.append(_("Data not entered."))
+        if self.template:
+            text.append(self._meta.get_field("template").verbose_name)
+        elif self.template_list:
+            text.append(self._meta.get_field("template_list").verbose_name)
+        else:
+            text.append(_("No template."))
+        return " + ".join([str(t) for t in text])
+
+    def get_data(self):
+        if self.context:
+            return self.context
+        elif self.file:
+            try:
+                return get_data_from_file(self.file)
+            except SourceParseFailure as err:
+                LOGGER.error(err)
+        elif self.source:
+            try:
+                return get_cached_data_from_url(self.pk, self.source, self.cached)
+            except SourceParseFailure as err:
+                LOGGER.error(err)
+        return None

djangocms_render_context/utils.py

@@ -0,0 +1,46 @@
+from collections.abc import ValuesView
+from datetime import date, datetime
+from typing import Union
+
+from django.utils.formats import localize
+
+dataType = Union[str, dict, list, ValuesView, None]  # noqa: UP007
+
+
+def get_data(data: dataType, level: int = 0) -> str:
+    wrapper, separator = "{}", "\n"
+    if level == 0:
+        separator = "</tr>\n<tr>\n"
+    if level == 1:
+        wrapper = "<td>{}</td>"
+    if data is None:
+        content = wrapper.format("")
+    elif isinstance(data, (date, datetime)):
+        content = wrapper.format(localize(data))
+    elif not isinstance(data, (tuple, list, dict, ValuesView)):
+        content = wrapper.format(data)
+    else:
+        content = collect_data(data, wrapper, separator, level)
+    return content
+
+
+def collect_data(data: dataType, wrapper: str, separator: str, level: int) -> str:
+    content = []
+    if isinstance(data, (tuple, list, ValuesView)):
+        for item in data:
+            content.append(wrapper.format(get_data(item, level + 1)))
+    elif isinstance(data, dict):
+        if "href" in data and "text" in data:
+            href, text = data.pop("href"), data.pop("text")
+            content.append(f"""<a href="{href}">{text}</a>""")
+        if "p" in data:
+            para = data.pop("p")
+            content.append(f"""<p>{para}</p>""")
+        content.append(wrapper.format(get_data(data.values(), level + 1)))
+    else:
+        content.append(wrapper.format(get_data(data, level + 1)))
+    return separator.join(content)
+
+
+def create_html(data: dataType) -> str:
+    return f"""<table class="rc-data"><tbody><tr>{get_data(data)}</tr></tbody></table>"""

djangocms_render_context-1.0.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: djangocms-render-context
+Version: 1.0.0
+Summary: Render context into template.
+Author-email: Zdeněk Böhm <zdenek.bohm@nic.cz>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://gitlab.nic.cz/djangocms-apps/djangocms-render-context
+Project-URL: Repository, https://gitlab.nic.cz/djangocms-apps/djangocms-render-context.git
+Project-URL: Changelog, https://gitlab.nic.cz/djangocms-apps/djangocms-render-context/-/blob/main/CHANGELOG.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django CMS
+Classifier: Framework :: Django CMS :: 4.1
+Classifier: Framework :: Django CMS :: 5.0
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: django-cms<6,>=4.0
+Requires-Dist: django-filer~=3.4
+Requires-Dist: pyyaml
+Requires-Dist: requests
+Provides-Extra: quality
+Requires-Dist: ruff; extra == "quality"
+Requires-Dist: mypy; extra == "quality"
+Requires-Dist: types-PyYAML; extra == "quality"
+Requires-Dist: types-requests; extra == "quality"
+Provides-Extra: test
+Requires-Dist: testfixtures; extra == "test"
+Requires-Dist: responses; extra == "test"
+
+# DjangoCMS Render Context
+
+The plugin for the [Django CMS](https://www.django-cms.org/) content management system.
+The plugin displays the context in the template. The context can be specified directly in JSON format.
+Or the context can be used as a media file. Or the context can be loaded from a URL.
+The template can be entered directly or selected from a list defined in the settings in the ``DJANGOCMS_RENDER_CONTEXT_TEMPLATES`` constant.
+
+Supported source data formats (mimetype):
+
+ - csv (text/csv)
+ - json (application/json)
+ - yaml (application/yaml)
+ - xml (application/xml)
+ - ods (application/vnd.oasis.opendocument.spreadsheet)
+
+## Install
+
+Install the package from pypi.org.
+
+```
+pip install djangocms-render-context
+```
+
+Add into `INSTALLED_APPS` in your site `settings.py`:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "easy_thumbnails",
+    "filer",
+    "djangocms_render_context",
+]
+```
+
+### Extra settings
+
+This value can be defined in settings.
+
+ - `DJANGOCMS_RENDER_CONTEXT_TEMPLATES` - List of templates that the plugin can use.
+
+For example:
+
+```python
+DJANGOCMS_RENDER_CONTEXT_TEMPLATES = (
+    ("", ""),
+    ("plugin.html", "Plugin"),
+    ("schedule.html", "Schedule"),
+)
+```
+
+
+## License
+
+BSD-3-Clause

djangocms_render_context-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+djangocms_render_context/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+djangocms_render_context/cache.py,sha256=PwagqDTqh3I83e7Ru52ei4P05juZ6Ob_pILukGGtsTo,99
+djangocms_render_context/cms_plugins.py,sha256=YBNH5Rh79xdC2puO3HOLZ0R6miUDBelGd-rmPAQ2Epo,1591
+djangocms_render_context/encoders.py,sha256=TIIcj_6vgXlUH5D0oeozCA7ixN4WNnfrnk15bAmfpQ8,253
+djangocms_render_context/exceptions.py,sha256=r5L-U90T_60CPSagcwWmu_r6DkbHAghg04uS8OvzTPo,69
+djangocms_render_context/forms.py,sha256=bpfoWoHUZXzhobH_fekH5txXRLQIKjMsxl8n6Yi-6fs,3754
+djangocms_render_context/loaders.py,sha256=JUFOwXCPbRG-4J79nrIT1AiRgq_je7km5VGhnO22Uxs,6774
+djangocms_render_context/models.py,sha256=BmdQQi47vZjkf1vaQr7KyfeSw9tAmY0atnoNfA2AgxI,3404
+djangocms_render_context/utils.py,sha256=HmkARbCxCJ6-SNRuH7zI4BY3BBf87c9cQuwBUNId53I,1632
+djangocms_render_context/locale/cs/LC_MESSAGES/django.mo,sha256=sxF9h5d4-av6CQoVXCSIKuIw_KMyCzmKJ7N74rD0hus,2903
+djangocms_render_context/locale/cs/LC_MESSAGES/django.po,sha256=bQMJnXI6CkCbMfbJ56SvirX1_rJOVwFLxJjFe2tsQeE,3157
+djangocms_render_context/migrations/0001_initial.py,sha256=bdIs0Jl8M8JcC-i03vxp612Lim_mUJ-BOaq2D3YI6uw,3854
+djangocms_render_context/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+djangocms_render_context-1.0.0.dist-info/METADATA,sha256=k1wb9eo0N7fBlLk8Xm4nv5zWddbQSJRjrcsQxYwEmSA,2865
+djangocms_render_context-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+djangocms_render_context-1.0.0.dist-info/top_level.txt,sha256=J82yBJeJTHoDzwzFIU3i4jFHxn3nAjgn-Fn5JSjVKQ8,25
+djangocms_render_context-1.0.0.dist-info/RECORD,,

djangocms_render_context-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

djangocms_render_context-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+djangocms_render_context