django-superset-integration 0.1.3__tar.gz

django_superset_integration-0.1.3/MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-include django_superset_integration/static *
+recursive-include django_superset_integration/templates *

django_superset_integration-0.1.3/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: django-superset-integration
+Version: 0.1.3
+Summary: A Django app to integrate Apache Superset dashboards into a Django application
+Author-email: Alica Burlot <alica.burlot@developpement-durable.gouv.fr>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/B-Alica/django-superset-integration
+Project-URL: Issues, https://github.com/B-Alica/django-superset-integration/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# django-superset-integration
+
+`django-superset-integration` is a Django app to integration Apache Superset dashboards into a Django application.
+
+## Quick start
+
+1. Add `django_superset_integration` to your `INSTALLED_APPS` setting like this:
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_superset_integration",
+    ...,
+]
+```
+
+2. Include the superset-integration URLconf in your project `urls.py` like this:
+
+```python
+path("superset_integration/", include("django_superset_integration.urls")),
+```
+
+3. You will need a cryptography Fernet key, so you need to install cryptography:
+
+```python
+pip install cryptography
+```
+
+4. Generate a Fernet key in a python terminal:
+
+```python
+from cryptography.fernet import Fernet
+FERNET_KEY = Fernet.generate_key()
+```
+
+5. The result is a bytestring like `b'jozEHFGLKJHEFUIHEZ4'`. **Copy ONLY the content of the string, not the b nor the quotation marks**
+
+6. In your env variables, create a variable `FERNET_KEY` with the copied content as value
+
+7. By default, all dashboard data will be displayed. You can override this by creating your own filtering function and adding it in your `settings.py`:
+
+```python
+RLS_FUNCTION = "my_app.my_module.create_rls_clause"
+```
+
+Your function must take a parameter `user` and return a SQL rls clause like this : `[{"clause": "1=1"}]`
+(where you replace 1=1 by the clause you want).
+
+See Superset documentation for more information
+
+8. Make sure that your Superset instance parameter `GUEST_TOKEN_JWT_EXP_SECONDS` is more than 300 (5 minutes). Otherwise it will expire before it can be refreshed. For example, set it to 600 (10 minutes).
+
+9. In the template where you want to integrate the dashboard, add the following in your `<head>`:
+
+```html
+<link href="{% static 'css/ponctual-rejects.css' %}" rel="stylesheet"/>
+```
+
+10. Then add the following at the emplacement where you want the dashboard:
+
+```html
+{% include "django_superset_integration/superset-integration.html" %}
+```
+
+11. In your view's `get_context_data`, add the following:
+
+```python
+dashboard_name = my_dashboard
+dashboard = SupersetDashboard.objects.get(name__iexact=dashboard_name)
+context["dashboard_integration_id"] = dashboard.integration_id
+context["dashboard_id"] = dashboard.id
+context["superset_domain"] = dashboard.domain.address
+```
+
+12. Run `python manage.py migrate` to create the models.
+
+13. Start the development server and visit the admin site to create a `SupersetInstance` object.
+
+14. After you have created a `SupersetInstance` object, create a `SupersetDashboard` object.
+
+15. That should be it!

django_superset_integration-0.1.3/README.md

@@ -0,0 +1,81 @@
+# django-superset-integration
+
+`django-superset-integration` is a Django app to integration Apache Superset dashboards into a Django application.
+
+## Quick start
+
+1. Add `django_superset_integration` to your `INSTALLED_APPS` setting like this:
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_superset_integration",
+    ...,
+]
+```
+
+2. Include the superset-integration URLconf in your project `urls.py` like this:
+
+```python
+path("superset_integration/", include("django_superset_integration.urls")),
+```
+
+3. You will need a cryptography Fernet key, so you need to install cryptography:
+
+```python
+pip install cryptography
+```
+
+4. Generate a Fernet key in a python terminal:
+
+```python
+from cryptography.fernet import Fernet
+FERNET_KEY = Fernet.generate_key()
+```
+
+5. The result is a bytestring like `b'jozEHFGLKJHEFUIHEZ4'`. **Copy ONLY the content of the string, not the b nor the quotation marks**
+
+6. In your env variables, create a variable `FERNET_KEY` with the copied content as value
+
+7. By default, all dashboard data will be displayed. You can override this by creating your own filtering function and adding it in your `settings.py`:
+
+```python
+RLS_FUNCTION = "my_app.my_module.create_rls_clause"
+```
+
+Your function must take a parameter `user` and return a SQL rls clause like this : `[{"clause": "1=1"}]`
+(where you replace 1=1 by the clause you want).
+
+See Superset documentation for more information
+
+8. Make sure that your Superset instance parameter `GUEST_TOKEN_JWT_EXP_SECONDS` is more than 300 (5 minutes). Otherwise it will expire before it can be refreshed. For example, set it to 600 (10 minutes).
+
+9. In the template where you want to integrate the dashboard, add the following in your `<head>`:
+
+```html
+<link href="{% static 'css/ponctual-rejects.css' %}" rel="stylesheet"/>
+```
+
+10. Then add the following at the emplacement where you want the dashboard:
+
+```html
+{% include "django_superset_integration/superset-integration.html" %}
+```
+
+11. In your view's `get_context_data`, add the following:
+
+```python
+dashboard_name = my_dashboard
+dashboard = SupersetDashboard.objects.get(name__iexact=dashboard_name)
+context["dashboard_integration_id"] = dashboard.integration_id
+context["dashboard_id"] = dashboard.id
+context["superset_domain"] = dashboard.domain.address
+```
+
+12. Run `python manage.py migrate` to create the models.
+
+13. Start the development server and visit the admin site to create a `SupersetInstance` object.
+
+14. After you have created a `SupersetInstance` object, create a `SupersetDashboard` object.
+
+15. That should be it!

django_superset_integration-0.1.3/django_superset_integration/admin.py

@@ -0,0 +1,87 @@
+from django.contrib import admin
+from django.contrib.admin.models import DELETION
+from django.utils.html import escape, format_html
+from django.urls import reverse
+
+from .models import (
+    SupersetInstance,
+    SupersetDashboard,
+)
+from .forms import SupersetInstanceCreationForm
+
+
+@admin.register(SupersetInstance)
+class SupersetInstanceAdmin(admin.ModelAdmin):
+    """
+    Admin model for SupersetInstance
+    Displayed name: "Instance Superset"
+
+    :model:`SupersetInstance`
+    """
+
+    add_form = SupersetInstanceCreationForm
+    model = SupersetInstance
+
+    list_display = (
+        "address",
+        "username",
+    )
+
+    list_filter = ("username",)
+
+    search_fields = (
+        "address",
+        "username",
+    )
+
+    ordering = (
+        "address",
+        "username",
+    )
+
+    def save_form(self, request, form, change):
+        """
+        Override admin.ModelAdmin.save_form
+        """
+        if not change:
+            form.instance = self.model.objects.create(
+                address=form.cleaned_data["address"],
+                username=form.cleaned_data["username"],
+            )
+            form.instance.set_password(form.cleaned_data["password"])
+        return super().save_form(request, form, change)
+
+    def get_fields(self, request, obj=None):
+        """
+        Exclude field "password" in change form
+        """
+        fields = super().get_fields(request, obj)
+        if obj:
+            fields.remove("password")
+        return fields
+
+
+@admin.register(SupersetDashboard)
+class SupersetDashboardAdmin(admin.ModelAdmin):
+    """
+    Admin model for SupersetDashboard
+
+    :model:`SupersetDashboard`
+    """
+
+    list_per_page = 20
+
+    list_display = (
+        "name",
+        "integration_id",
+        "domain",
+    )
+
+    ordering = ("name",)
+
+    search_fields = (
+        "name",
+        "domain",
+    )
+
+    list_filter = ("domain",)

django_superset_integration-0.1.3/django_superset_integration/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class SupersetIntegrationConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_superset_integration"
+    label = "superset_integration"

django_superset_integration-0.1.3/django_superset_integration/fetch_superset_guest_token.py

@@ -0,0 +1,129 @@
+import importlib
+import requests
+from cryptography.fernet import Fernet
+
+from django.http import HttpResponse
+from django.views.decorators.http import require_safe
+from django.conf import settings
+
+from .models import SupersetDashboard
+
+
+def create_rls_clause(user):
+    """
+    SQL clause to apply to the dashboard data
+    Can be adjusted to limit data displayed in the dashboard
+    Clause "1=1" apply no filter, so we get all the data
+    Clause "1=0" get no data
+
+    Return format : [{"clause": "1=1"}]
+    """
+
+    if not user:
+        # No data
+        return [{"clause": "1=0"}]
+
+    # All data
+    return [{"clause": "1=1"}]
+
+
+@require_safe
+def fetch_superset_guest_token(request, dashboard_id: str):
+    """
+    Get a guest token for integration of a Superset dashboard
+    1 - Get an access token
+    2 - Get a CSRF token by using the access token
+    3 - Get a guest token by using the CSRF token
+
+    Return a HttpResponse with the guest token
+
+    Parameters:
+        request
+        dashboard_id (str): SupersetDashboard object ID in database
+            (not to be confused with attribute integration_id of
+            SupersetDashboard object, which is used to integrate the
+            dashboard with SupersetEmbeddedSdk)
+    """
+    # Get a guest_token from Superset API
+    # The guest_token allow client access to the Superset dashboard
+    with requests.Session() as session:
+        dashboard = SupersetDashboard.objects.get(id=int(dashboard_id))
+        dashboard_integration_id = dashboard.integration_id
+        superset_domain = dashboard.domain.address
+        superset_username = dashboard.domain.username
+
+        # Authentication for API access
+        url = f"https://{superset_domain}/api/v1/security/login"
+
+        def get_password(password):
+            cipher_suite = Fernet(settings.ENCRYPTION_KEY)
+            decrypted_password = cipher_suite.decrypt(password.encode())
+            return decrypted_password.decode()
+
+        params = {
+            "provider": "db",
+            "refresh": "True",
+            "username": superset_username,
+            "password": get_password(dashboard.domain.password),
+        }
+        session.headers.update({"Content-Type": "application/json"})
+        response = session.post(url, json=params)
+
+        access_token = response.json()["access_token"]
+
+        session.headers.update({"Authorization": f"Bearer {access_token}"})
+        url = f"https://{superset_domain}/api/v1/security/csrf_token/"
+        response = session.get(url)
+        csrf_token = response.json()["result"]
+
+        cookie = response.headers["set-cookie"].split("; ")[0]
+
+        try:
+            user = request.user
+        except Exception:
+            # If no user, no guest_token
+            return False
+
+        # SQL clause to apply to the dashboard data
+        # Can be adjusted to limit data displayed in the dashboard
+        # Clause "1=1" apply no filter, so we get all the data
+        # Clause "1=0" get no data
+        # the default function can be overridden by creating
+        # your own and setting its path in settings.RLS_FUNCTION
+        rls_function_path = getattr(settings, "RLS_FUNCTION", None)
+        if rls_function_path:
+            # Dynamically import the function
+            module_path, func_name = rls_function_path.rsplit(".", 1)
+            module = importlib.import_module(module_path)
+            rls_function = getattr(module, func_name)
+        else:
+            rls_function = create_rls_clause
+
+        rls = rls_function(user)
+
+        if not rls:
+            # If no rls clause, show no data
+            rls = [{"clause": "1=0"}]
+
+        # Get guest_token to display the dashboard
+        params = {
+            "resources": [
+                {"id": dashboard_integration_id, "type": "dashboard"}
+            ],
+            "rls": rls,
+            "user": {
+                "first_name": "Prenom",
+                "last_name": "Nom",
+                "username": superset_username,
+            },
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "X-Csrftoken": csrf_token,
+            "Cookie": cookie,
+        }
+        session.headers.update(headers)
+        url = f"https://{superset_domain}/api/v1/security/guest_token/"
+        response = session.post(url, json=params)
+        guest_token = response.json()["token"]
+        return HttpResponse(guest_token)

django_superset_integration-0.1.3/django_superset_integration/forms.py

@@ -0,0 +1,38 @@
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+from .models import SupersetInstance
+
+
+class SupersetInstanceCreationForm(forms.ModelForm):
+    """
+    SupersetInstance creation form
+    """
+
+    address = forms.CharField(
+        widget=forms.TextInput(
+            attrs={"autofocus": True, "required": True, "id": "address-field"}
+        )
+    )
+
+    username = forms.CharField(
+        widget=forms.TextInput(
+            attrs={"required": True, "id": "username-field"}
+        )
+    )
+
+    password = forms.CharField(
+        label=_("Password"),
+        strip=False,
+        widget=forms.PasswordInput(
+            attrs={"required": True, id: "password-field"}
+        ),
+    )
+
+    class Meta:
+        model = SupersetInstance
+        fields = (
+            "address",
+            "username",
+            "password",
+        )

django_superset_integration-0.1.3/django_superset_integration/migrations/0001_initial.py

@@ -0,0 +1,103 @@
+# Generated by Django 5.1.4 on 2025-03-03 12:27
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="SupersetInstance",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "address",
+                    models.CharField(
+                        max_length=250,
+                        unique=True,
+                        verbose_name="adresse de l'instance Superset",
+                    ),
+                ),
+                (
+                    "username",
+                    models.CharField(
+                        default="superset_api",
+                        max_length=250,
+                        verbose_name="nom d'utilisateur",
+                    ),
+                ),
+                (
+                    "password",
+                    models.CharField(
+                        blank=True,
+                        max_length=128,
+                        null=True,
+                        verbose_name="mot de passe",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="SupersetDashboard",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "integration_id",
+                    models.CharField(
+                        max_length=50,
+                        unique=True,
+                        verbose_name="ID d'intégration",
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(
+                        max_length=250, unique=True, verbose_name="Nom"
+                    ),
+                ),
+                (
+                    "comment",
+                    models.TextField(
+                        blank=True, null=True, verbose_name="Commentaire"
+                    ),
+                ),
+                (
+                    "superset_link",
+                    models.CharField(
+                        blank=True,
+                        max_length=500,
+                        null=True,
+                        verbose_name="Lien vers le dashboard dans Superset",
+                    ),
+                ),
+                (
+                    "domain",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="superset_integration.supersetinstance",
+                    ),
+                ),
+            ],
+        ),
+    ]

django_superset_integration-0.1.3/django_superset_integration/models.py

@@ -0,0 +1,142 @@
+from django.db import models
+from django.conf import settings
+from django.contrib.admin.models import LogEntry
+from django.db.models.signals import pre_save
+from django.dispatch import receiver
+
+from cryptography.fernet import Fernet
+
+
+class SupersetInstance(models.Model):
+    """
+    SupersetInstance model containing your Superset instance's address
+    and the username to access it
+    ...
+
+    Attributes
+    ----------
+    address: str
+        Url address of your Superset instance
+
+    username: str
+        Username to access your Superset instance
+        By default: "superset_api"
+
+    password: str
+        Password to access your Superset instance
+
+    Methods
+    ----------
+    set_password(self, raw_password):
+        Set password in password field after hashing it with django.contrib.auth.hashers.make_password
+    """
+
+    address = models.CharField(
+        "adresse de l'instance Superset",
+        max_length=250,
+        blank=False,
+        null=False,
+        unique=True,
+    )
+
+    username = models.CharField(
+        "nom d'utilisateur",
+        max_length=250,
+        blank=False,
+        null=False,
+        default="superset_api",
+    )
+
+    password = models.CharField(
+        "mot de passe",
+        max_length=128,
+        blank=True,
+        null=True,
+    )
+
+    def __str__(self):
+        return f"Instance Superset : {self.address}"
+
+    def set_password(self, raw_password):
+        cipher_suite = Fernet(settings.ENCRYPTION_KEY)
+        encrypted_password = cipher_suite.encrypt(raw_password.encode())
+        self.password = encrypted_password.decode()
+
+
+@receiver(pre_save, sender=SupersetInstance)
+def superset_instance_pre_save_handler(sender, instance, *args, **kwargs):
+    """
+    SupersetInstance.address should not begin with "http://" or "https://"
+    so we remove this part if necessary
+    """
+
+    if instance.address.startswith("http://") or instance.address.startswith(
+        "https://"
+    ):
+        instance.address = instance.address.split("//", 1)[1]
+
+
+class SupersetDashboard(models.Model):
+    """
+    SupersetDashboard containing the integration ID and
+    name of your Superset dashboard
+    ...
+
+    Attributes
+    ----------
+    integration_id: str
+        Integratrion ID of your Superset dashboard
+        Format : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        where x are numbers and letters
+
+    name: str
+        Name of the dashboard
+
+    domain: SupersetInstance
+        Foreign key
+        Superset instance containing the dashboard
+
+    comment: str
+        Free text field for your comments
+
+    superset_link: str
+        Link to the dashboard in Superset
+    """
+
+    integration_id = models.CharField(
+        "ID d'intégration",
+        max_length=50,
+        blank=False,
+        null=False,
+        unique=True,
+    )
+
+    name = models.CharField(
+        "Nom",
+        max_length=250,
+        blank=False,
+        null=False,
+        unique=True,
+    )
+
+    domain = models.ForeignKey(
+        SupersetInstance,
+        on_delete=models.CASCADE,
+        null=False,
+    )
+
+    comment = models.TextField(
+        "Commentaire",
+        blank=True,
+        null=True,
+    )
+
+    superset_link = models.CharField(
+        "Lien vers le dashboard dans Superset",
+        max_length=500,
+        blank=True,
+        null=True,
+    )
+
+    def __str__(self):
+        return f"Dashboard : {self.name}"

django_superset_integration-0.1.3/django_superset_integration/static/django_superset_integration/css/django-superset-integration.css

@@ -0,0 +1,16 @@
+#superset-fullscreen-exit {
+    visibility: hidden;
+    z-index: 1;
+    position: fixed;
+    top: 10px;
+    right: 10px;
+}
+
+.fullScreen {
+    width: 100%;
+    height: 100%;
+    z-index: 0;
+    position: absolute;
+    top: 0;
+    left: 0;
+}

django_superset_integration-0.1.3/django_superset_integration/templates/django_superset_integration/superset-integration.html

@@ -0,0 +1,72 @@
+{% load static %}
+
+<link href="{% static 'superset_integration/css/superset-integration.css' %}" rel="stylesheet"/>
+
+<button id="superset-fullscreen" class="fr-btn fr-mb-3w">
+    Afficher en plein écran
+</button>
+
+<button id="superset-fullscreen-exit" class="fr-btn">
+    Quitter le mode plein écran
+</button>
+
+<div id="superset-integration">
+</div>
+
+<script src="{% static 'js/superset-embedded-sdk.js' %}"></script>
+<script>
+    // Get guest token from django app backend
+    // The token has a lifetime of 5 min. This function is called
+    // periodically to refresh the token
+    async function fetchGuestTokenFromBackend() {
+        const response = await fetch('/superset_integration/guest_token/{{ dashboard_id }}');
+        const token = await response.text();
+        return token;
+    }
+
+    // Display dashboard inside #graph element
+    supersetEmbeddedSdk.embedDashboard({
+        id: "{{ dashboard_integration_id }}",
+        supersetDomain: "https://" + "{{ superset_domain }}",
+        mountPoint: document.getElementById("superset-integration"),
+        fetchGuestToken: () => fetchGuestTokenFromBackend(),
+        dashboardUiConfig: {
+            hideTitle: true,
+            filters: {
+                expanded: true,
+            }
+        },
+    });
+
+    let iframe = document.getElementById("superset-integration").firstElementChild;
+    let iframe_height = "1200px";
+
+    $(window).on('load',function () {
+        {% if iframe_height and iframe_height.isdigit %}
+            iframe_height = "{{ iframe_height }}px";
+        {% elif iframe_height %}
+            iframe_height = "{{ iframe_height }}";
+        {% endif %}
+        iframe.height = iframe_height;
+    });
+
+    $("#superset-fullscreen").click(function(ev)
+    {
+        $(".fr-header").hide();
+        $(".fr-footer").hide();
+        $("#superset-fullscreen-exit").show();
+        $("#superset-fullscreen-exit").css({visibility: "visible"});
+        $("#superset-fullscreen-exit").css({opacity: 100});
+        $("#superset-integration").addClass("fullScreen");
+        iframe.height = "100%";
+    });
+
+    $("#superset-fullscreen-exit").click(function(ev)
+    {
+        $(".fr-header").show();
+        $(".fr-footer").show();
+        $("#superset-fullscreen-exit").hide();
+        $("#superset-integration").removeClass("fullScreen");
+        iframe.height = iframe_height;
+    });
+</script>

django_superset_integration-0.1.3/django_superset_integration/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+
+from .fetch_superset_guest_token import fetch_superset_guest_token
+
+urlpatterns = [
+    path(
+        "guest_token/<slug:dashboard_id>",
+        fetch_superset_guest_token,
+        name="guest-token",
+    ),
+]

django_superset_integration-0.1.3/django_superset_integration.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: django-superset-integration
+Version: 0.1.3
+Summary: A Django app to integrate Apache Superset dashboards into a Django application
+Author-email: Alica Burlot <alica.burlot@developpement-durable.gouv.fr>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/B-Alica/django-superset-integration
+Project-URL: Issues, https://github.com/B-Alica/django-superset-integration/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# django-superset-integration
+
+`django-superset-integration` is a Django app to integration Apache Superset dashboards into a Django application.
+
+## Quick start
+
+1. Add `django_superset_integration` to your `INSTALLED_APPS` setting like this:
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_superset_integration",
+    ...,
+]
+```
+
+2. Include the superset-integration URLconf in your project `urls.py` like this:
+
+```python
+path("superset_integration/", include("django_superset_integration.urls")),
+```
+
+3. You will need a cryptography Fernet key, so you need to install cryptography:
+
+```python
+pip install cryptography
+```
+
+4. Generate a Fernet key in a python terminal:
+
+```python
+from cryptography.fernet import Fernet
+FERNET_KEY = Fernet.generate_key()
+```
+
+5. The result is a bytestring like `b'jozEHFGLKJHEFUIHEZ4'`. **Copy ONLY the content of the string, not the b nor the quotation marks**
+
+6. In your env variables, create a variable `FERNET_KEY` with the copied content as value
+
+7. By default, all dashboard data will be displayed. You can override this by creating your own filtering function and adding it in your `settings.py`:
+
+```python
+RLS_FUNCTION = "my_app.my_module.create_rls_clause"
+```
+
+Your function must take a parameter `user` and return a SQL rls clause like this : `[{"clause": "1=1"}]`
+(where you replace 1=1 by the clause you want).
+
+See Superset documentation for more information
+
+8. Make sure that your Superset instance parameter `GUEST_TOKEN_JWT_EXP_SECONDS` is more than 300 (5 minutes). Otherwise it will expire before it can be refreshed. For example, set it to 600 (10 minutes).
+
+9. In the template where you want to integrate the dashboard, add the following in your `<head>`:
+
+```html
+<link href="{% static 'css/ponctual-rejects.css' %}" rel="stylesheet"/>
+```
+
+10. Then add the following at the emplacement where you want the dashboard:
+
+```html
+{% include "django_superset_integration/superset-integration.html" %}
+```
+
+11. In your view's `get_context_data`, add the following:
+
+```python
+dashboard_name = my_dashboard
+dashboard = SupersetDashboard.objects.get(name__iexact=dashboard_name)
+context["dashboard_integration_id"] = dashboard.integration_id
+context["dashboard_id"] = dashboard.id
+context["superset_domain"] = dashboard.domain.address
+```
+
+12. Run `python manage.py migrate` to create the models.
+
+13. Start the development server and visit the admin site to create a `SupersetInstance` object.
+
+14. After you have created a `SupersetInstance` object, create a `SupersetDashboard` object.
+
+15. That should be it!

django_superset_integration-0.1.3/django_superset_integration.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+MANIFEST.in
+README.md
+pyproject.toml
+django_superset_integration/__init__.py
+django_superset_integration/admin.py
+django_superset_integration/apps.py
+django_superset_integration/fetch_superset_guest_token.py
+django_superset_integration/forms.py
+django_superset_integration/models.py
+django_superset_integration/urls.py
+django_superset_integration.egg-info/PKG-INFO
+django_superset_integration.egg-info/SOURCES.txt
+django_superset_integration.egg-info/dependency_links.txt
+django_superset_integration.egg-info/top_level.txt
+django_superset_integration/migrations/0001_initial.py
+django_superset_integration/migrations/__init__.py
+django_superset_integration/static/django_superset_integration/css/django-superset-integration.css
+django_superset_integration/templates/django_superset_integration/superset-integration.html

django_superset_integration-0.1.3/django_superset_integration.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_superset_integration-0.1.3/django_superset_integration.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_superset_integration

django_superset_integration-0.1.3/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-superset-integration"
+version = "0.1.3"
+description = "A Django app to integrate Apache Superset dashboards into a Django application"
+authors = [
+    {name = "Alica Burlot",email = "alica.burlot@developpement-durable.gouv.fr"}
+]
+license = "GPL-3.0-or-later"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/B-Alica/django-superset-integration"
+Issues = "https://github.com/B-Alica/django-superset-integration/issues"

django_superset_integration-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+