df_site 0.1.0__py3-none-any.whl

df_site/context_processors.py

@@ -0,0 +1,61 @@
+"""Define the context processors with global variables about the site."""
+
+import datetime
+import logging
+from functools import lru_cache
+from typing import Any, Dict, Iterable, Optional
+
+from django.conf import settings
+from django.db.models import Q
+from django.http import HttpRequest
+from django.utils.timezone import now
+
+from df_site.models import AlertRibbon
+from df_site.user_settings import get_user_setting
+
+logger = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=1)
+def get_current_ribbons(current_date: datetime.datetime) -> Iterable[AlertRibbon]:
+    """Get the active ribbons for the current date.
+
+    The current date will be rounded to the nearest hour.
+    """
+    return list(
+        AlertRibbon.objects.filter(
+            Q(Q(end_date__gte=current_date) & Q(end_date__isnull=False)) | Q(end_date__isnull=True),
+            Q(Q(start_date__lte=current_date) & Q(start_date__isnull=False)) | Q(start_date__isnull=True),
+            is_active=True,
+        )
+    )
+
+
+def global_site_infos(request: HttpRequest, current_date: Optional[datetime.datetime] = None) -> Dict[str, Any]:
+    """Adds a few values to the request context."""
+    try:
+        color_theme = get_user_setting("color_theme", request=request)
+    except Exception as e:
+        logger.error("Error getting color theme: %s", e)
+        color_theme = settings.DF_SITE_THEMES[0][0]
+    if current_date is None:
+        current_date = now()
+    current_date = current_date.replace(minute=0, second=0, microsecond=0)
+    ribbons = get_current_ribbons(current_date)
+    x_url = settings.DF_SITE_SOCIAL_NETWORKS.get("twitter", "")
+    __, __, df_site_x_account = x_url.rpartition("/")
+    return {
+        "DF_SITE_TITLE": settings.DF_SITE_TITLE,
+        "DF_SITE_DESCRIPTION": settings.DF_SITE_DESCRIPTION,
+        "DF_SITE_KEYWORDS": settings.DF_SITE_KEYWORDS,
+        "DF_SITE_AUTHOR": settings.DF_SITE_AUTHOR,
+        "DF_SITE_ORGANIZATION": settings.DF_SITE_ORGANIZATION,
+        "DF_SITE_X_ACCOUNT": df_site_x_account,
+        "DF_SITE_SOCIAL_NETWORKS": settings.DF_SITE_SOCIAL_NETWORKS.items(),
+        "DF_COLOR_THEMES": settings.DF_SITE_THEMES,
+        "DF_MICROSOFT_BACKGROUND_COLOR": settings.DF_MICROSOFT_BACKGROUND_COLOR,
+        "DF_ANDROID_THEME_COLOR": settings.DF_ANDROID_THEME_COLOR,
+        "DF_SAFARI_PINNED_COLOR": settings.DF_SAFARI_PINNED_COLOR,
+        "COLOR_THEME": color_theme,
+        "DF_RIBBONS": ribbons,
+    }

df_site/defaults.py

@@ -0,0 +1,319 @@
+"""Django settings for the project."""
+
+from typing import List, Tuple
+
+from df_config.config.dynamic_settings import CallableSetting, SettingReference
+from django.utils.translation import gettext_lazy as _
+
+from df_site.dynamic_settings import allauth_signup_form, are_tests_running, load_tox_environment
+
+load_tox_environment()
+DF_SITE_TITLE = "More batteries to Django"
+DF_SITE_SECURITY_EMAIL = SettingReference("ADMIN_EMAIL")
+DF_SITE_SECURITY_LANGUAGE_CODE = SettingReference("LANGUAGE_CODE")
+DF_SITE_SECURITY_GPG_CONTENT = None
+
+DF_SITE_DESCRIPTION = "A simple Django site with lots of batteries included."
+DF_SITE_KEYWORDS = ["Django", "Bootstrap", "WebSockets", "HTMX", "Django Channels"]
+DF_SITE_AUTHOR = "d9pouces"
+DF_SITE_ORGANIZATION = "d9pouces"
+DF_SITE_SOCIAL_NETWORKS = {
+    "instagram": "https://www.instagram.com/d9pouces/",
+    "twitter": "https://x.com/d9pouces/",
+    "github": "https://github.com/d9pouces/",
+}
+
+DF_SITE_THEMES: List[Tuple[str, str, str]] = [  # ('theme name', 'theme label', 'icon name')
+    ("auto", _("Auto"), "toggle-on"),
+    ("light", _("Light"), "sun"),
+    ("dark", _("Dark"), "moon"),
+]
+DF_ANDROID_THEME_COLOR = "#ffffff"
+DF_ANDROID_BACKGROUND_COLOR = "#ffffff"
+DF_MICROSOFT_BACKGROUND_COLOR = "#da532c"
+DF_SAFARI_PINNED_COLOR = "#5bbad5"
+
+DF_IMAGE_THUMBNAILS = {
+    "media": {
+        "src_storage": "default",
+        "dst_storage": "staticfiles",
+        "cache": "default",
+        "prefix": "T",
+        "reversible": True,
+    },
+    "static": {
+        "src_storage": "staticfiles",
+        "dst_storage": "staticfiles",
+        "cache": "default",
+        "prefix": "S",
+        "reversible": True,
+    },
+}
+
+CSP_IMG_SRC = ["'self'", "data: w3.org/svg/2000", "https://log.pinterest.com"]
+# "https://log.pinterest.com" is used for Pinterest
+CSP_STYLE_SRC = ["'self'"]
+CSP_FONT_SRC = ["'self'"]
+CSP_DEFAULT_SRC = ["'none'"]
+CSP_SCRIPT_SRC = [
+    "'self'",
+    "https://www.google.com",
+    "https://www.gstatic.com",
+    "https://assets.pinterest.com",
+    "'unsafe-inline'",
+]
+# unsafe-inline is used for django-allauth (inline JS)
+# "https://www.google.com", "https://www.gstatic.com" are used for reCAPTCHA
+# "https://assets.pinterest.com" is used for Pinterest
+CSP_OBJECT_SRC = ["'self'"]
+CSP_MEDIA_SRC = ["'self'"]
+CSP_FRAME_SRC = ["'self'", "https://www.google.com", "https://assets.pinterest.com"]
+# "https://www.google.com" is used for reCAPTCHA
+# "https://assets.pinterest.com" is used for Pinterest
+CSP_CHILD_SRC = ["'self'"]
+CSP_FRAME_ANCESTORS = ["'self'"]
+CSP_FORM_ACTION = ["'self'"]
+CSP_MANIFEST_SRC = ["'self'"]
+CSP_BASE_URI = ["'self'"]
+CSP_REPORT_URI = "/csp-report/"
+CSP_REPORT_TO = None
+DF_TEMPLATE_CONTEXT_PROCESSORS = [
+    "df_site.context_processors.global_site_infos",
+    "django.template.context_processors.request",
+]
+TESTING = CallableSetting(are_tests_running)
+RECAPTCHA_PUBLIC_KEY = ""
+RECAPTCHA_PRIVATE_KEY = ""
+DF_INSTALLED_APPS = [
+    "django_bootstrap5",
+    "df_site.apps.DFSiteApp",
+    "cookie_consent",
+    "postman",
+    "allauth.mfa",
+    "allauth.usersessions",
+    "django_ckeditor_5",
+    "django_recaptcha",
+]
+
+DF_MIDDLEWARE = [
+    "allauth.usersessions.middleware.UserSessionsMiddleware",
+    "df_websockets.middleware.WebsocketMiddleware",
+    "df_site.middleware.websocket_middleware",
+]
+MIDDLEWARE = [
+    "django_prometheus.middleware.PrometheusBeforeMiddleware",
+    "django.middleware.cache.UpdateCacheMiddleware",
+    "debug_toolbar.middleware.DebugToolbarMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.middleware.locale.LocaleMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+    "django.middleware.security.SecurityMiddleware",
+    "df_config.apps.middleware.DFConfigMiddleware",
+    "allauth.usersessions.middleware.UserSessionsMiddleware",
+    "df_websockets.middleware.WebsocketMiddleware",
+    "df_site.middleware.websocket_middleware",
+    "csp.middleware.CSPMiddleware",
+    "allauth.account.middleware.AccountMiddleware",
+    "django.middleware.cache.FetchFromCacheMiddleware",
+    "django_prometheus.middleware.PrometheusAfterMiddleware",
+]
+USERSESSIONS_TRACK_ACTIVITY = True
+POSTMAN_DISALLOW_ANONYMOUS = True
+POSTMAN_AUTO_MODERATE_AS = True
+POSTMAN_I18N_URLS = False
+AUTH_USER_MODEL = "df_site.PreferencesUser"
+AUTH_USER_SETTINGS_VIEW = "df_site.users.views.UserSettingsView"
+COOKIE_CONSENT_SECURE = SettingReference("USE_SSL")
+COOKIE_CONSENT_DOMAIN = "{SERVER_NAME}"
+COOKIE_CONSENT_SAMESITE = "Strict"
+PIPELINE = {
+    "PIPELINE_ENABLED": SettingReference("PIPELINE_ENABLED"),
+    "JAVASCRIPT": {
+        "base": {
+            "source_filenames": [
+                "js/base.js",
+                "js/df_websockets.min.js",
+                # "django_ckeditor_5/dist/bundle.js"
+            ],
+            "output_filename": "js/base.min.js",
+            #            "integrity": "sha384",
+            "crossorigin": "anonymous",
+            "extra_context": {
+                "defer": True,
+            },
+        },
+        "app": {
+            "source_filenames": ["js/app.ts"],
+            "output_filename": "js/app.min.js",
+            #            "integrity": "sha384",
+            "crossorigin": "anonymous",
+            "extra_context": {
+                "defer": True,
+            },
+        },
+    },
+    "STYLESHEETS": {
+        "base": {
+            "source_filenames": [
+                "django_ckeditor_5/src/override-django.css",
+                "css/ckeditor5.css",
+                "css/base.css",
+            ],
+            "output_filename": "css/base.min.css",
+            "extra_context": {"media": "all"},
+            #            "integrity": "sha384",
+            "crossorigin": "anonymous",
+        },
+        "app": {
+            "source_filenames": ["css/app.css"],
+            "output_filename": "css/app.min.css",
+            "extra_context": {"media": "all"},
+            #            "integrity": "sha384",
+            "crossorigin": "anonymous",
+        },
+    },
+    "CSS_COMPRESSOR": "pipeline.compressors.yuglify.YuglifyCompressor",
+    "JS_COMPRESSOR": "pipeline.compressors.uglifyjs.UglifyJSCompressor",
+    "COMPILERS": [],
+}
+SOCIALACCOUNT_EMAIL_AUTHENTICATION_AUTO_CONNECT = True
+SOCIALACCOUNT_LOGIN_ON_GET = True
+MFA_SUPPORTED_TYPES = ["totp", "webauthn", "recovery_codes"]
+MFA_PASSKEY_LOGIN_ENABLED = True
+MFA_WEBAUTHN_ALLOW_INSECURE_ORIGIN = SettingReference("DEBUG")
+ACCOUNT_LOGIN_BY_CODE_ENABLED = True
+ACCOUNT_EMAIL_VERIFICATION = "optional"
+ACCOUNT_SIGNUP_FORM_CLASS = CallableSetting(allauth_signup_form)
+
+CKEDITOR_5_USER_LANGUAGE = True
+special_chars = [
+    {"title": _("smiley face"), "character": "😊"},
+    {"title": _("smiley face"), "character": ":)"},
+]
+CK_EDITOR_5_UPLOAD_FILE_VIEW = "django_ckeditor_5.views.upload_file"
+CK_EDITOR_5_UPLOAD_FILE_VIEW_NAME = "upload_file"
+CKEDITOR_5_CONFIGS = {
+    "inline": {
+        "specialChars": special_chars,
+        "toolbar": [
+            "bold",
+            "italic",
+            "underline",
+            "strikethrough",
+            "subscript",
+            "superscript",
+            "|",
+            "specialCharacters",
+            "removeFormat",
+        ],
+        "plugins": [
+            "Essentials",
+            "Autoformat",
+            "Bold",
+            "Italic",
+            "Underline",
+            "Strikethrough",
+            "Code",
+            "Subscript",
+            "Superscript",
+            "Paragraph",
+            "Font",
+            "PasteFromOffice",
+            "RemoveFormat",
+            "Highlight",
+            "SpecialCharacters",
+            "SpecialCharactersEssentials",
+            "ShowBlocks",
+            "SelectAll",
+        ],
+    },
+    "inline_link": {
+        "specialChars": special_chars,
+        "toolbar": [
+            "bold",
+            "italic",
+            "underline",
+            "strikethrough",
+            "subscript",
+            "superscript",
+            "link",
+            "|",
+            "specialCharacters",
+            "removeFormat",
+        ],
+        "plugins": [
+            "Essentials",
+            "Autoformat",
+            "Bold",
+            "Italic",
+            "Underline",
+            "Strikethrough",
+            "Code",
+            "Subscript",
+            "Superscript",
+            "Link",
+            "Paragraph",
+            "Font",
+            "PasteFromOffice",
+            "RemoveFormat",
+            "Highlight",
+            "SpecialCharacters",
+            "SpecialCharactersEssentials",
+            "ShowBlocks",
+            "SelectAll",
+        ],
+    },
+    "default": {
+        "specialChars": special_chars,
+        "toolbar": [
+            "heading",
+            "bulletedList",
+            "numberedList",
+            "blockQuote",
+            "|",
+            "bold",
+            "italic",
+            "underline",
+            "strikethrough",
+            "subscript",
+            "superscript",
+            "link",
+            "highlight",
+            "|",
+            "insertTable",
+            "insertImage",
+            "specialCharacters",
+            "removeFormat",
+            "undo",
+            "redo",
+        ],
+        "image": {
+            "toolbar": [
+                "imageTextAlternative",
+                "|",
+                "imageStyle:full",
+                "imageStyle:alignLeft",
+                "imageStyle:alignRight",
+                "imageStyle:alignCenter",
+                "imageStyle:side",
+                "|",
+            ],
+            "styles": [
+                "full",
+                "side",
+                "alignLeft",
+                "alignRight",
+                "alignCenter",
+            ],
+        },
+        "list": {"properties": {"styles": False, "startIndex": True, "reversed": True}},
+        "table": {
+            "defaultHeadings": {"rows": 1, "columns": 1},
+            "contentToolbar": ["tableColumn", "tableRow", "mergeTableCells"],
+        },
+    },
+}

df_site/dynamic_settings.py

@@ -0,0 +1,37 @@
+"""Python functions to provide Django settings depending on other settings."""
+
+import os
+from typing import Any, Optional
+
+
+def allauth_signup_form(values: dict[str, Any]) -> Optional[str]:
+    """Return the form class to use for signing up."""
+    if values.get("RECAPTCHA_PRIVATE_KEY") and values.get("RECAPTCHA_PUBLIC_KEY"):
+        return "df_site.users.forms.ReCaptchaForm"
+    return None
+
+
+allauth_signup_form.required_settings = ["RECAPTCHA_PRIVATE_KEY", "RECAPTCHA_PUBLIC_KEY"]
+
+
+def are_tests_running(values: dict[str, Any]) -> bool:
+    """Return True if we are running unit tests."""
+    return "testserver" in values.get("ALLOWED_HOSTS", [])
+
+
+are_tests_running.required_settings = ["ALLOWED_HOSTS"]
+
+
+def load_tox_environment():
+    """Is a workaround for https://github.com/tox-dev/tox-docker/issues/55."""
+    if os.environ.get("REDIS_HOST") and os.environ.get("REDIS_6379_TCP_PORT"):
+        os.environ["REDIS_URL"] = f'redis://:p_df_site@{os.environ["REDIS_HOST"]}:{os.environ["REDIS_6379_TCP_PORT"]}/1'
+    if os.environ.get("POSTGRES_HOST") and os.environ.get("POSTGRES_5432_TCP_PORT"):
+        os.environ["DATABASE_URL"] = (
+            f'postgresql://u_df_site:p_df_site@{os.environ["POSTGRES_HOST"]}:'
+            f'{os.environ["POSTGRES_5432_TCP_PORT"]}/d_df_site'
+        )
+    if os.environ.get("MINIO_HOST") and os.environ.get("MINIO_9000_TCP_PORT"):
+        os.environ["MAIN_STORAGE_DIR"] = (
+            f's3:http://u_df_site:p_df_site@127.0.0.1:' f'{os.environ["MINIO_9000_TCP_PORT"]}/f_df_site'
+        )

df_site/form_fields.py

@@ -0,0 +1,138 @@
+"""Custom form fields for the df_site app."""
+
+import html
+from functools import lru_cache
+from typing import Dict, Iterable, List, Set
+
+import nh3
+from django import forms
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.utils.html import strip_tags
+from django_ckeditor_5.widgets import CKEditor5Widget
+from lxml_html_clean import autolink_html
+
+# list of CKEditor5 plugins and associated HTML tags
+BLOCK = "$block"
+TAGS_BY_PLUGIN: Dict[str, Dict[str, List[str]]] = {
+    "Alignment": {BLOCK: ["class"]},
+    "BlockQuote": {"blockquote": []},
+    "Bold": {"strong": []},
+    "Code": {"code": []},
+    "CodeBlock": {"pre": ["class"], "code": ["class"]},
+    "Essentials": {"br": []},
+    "Font": {"span": ["class"]},
+    "Heading": {"h1": [], "h2": [], "h3": [], "h4": []},
+    "Highlight": {"mark": ["class"]},
+    "HorizontalLine": {"hr": []},
+    "HtmlEmbed": {"div": ["class"]},
+    "Image": {"figure": ["class"], "img": []},
+    "ImageCaption": {"figcaption": []},
+    "Indent": {BLOCK: ["class"]},
+    "Italic": {"i": []},
+    "Link": {"a": ["rel", "href"]},
+    "List": {"ol": [], "ul": [], "li": []},
+    "ListProperties": {"ol": [], "ul": [], "li": []},
+    "MediaEmbed": {
+        "figure": ["class"],
+        "oembed": ["url"],
+        "div": ["data-oembed-url"],
+        "iframe": ["frameborder", "src", "allow"],
+    },
+    "Mention": {"span": ["class", "data-mention"]},
+    "Paragraph": {"p": []},
+    "Strikethrough": {"s": []},
+    "Subscript": {"sub": []},
+    "Superscript": {"sup": []},
+    "Table": {
+        "figure": ["class"],
+        "table": [],
+        "thead": [],
+        "tbody": [],
+        "tr": [],
+        "td": ["colspan", "rowspan"],
+        "th": ["colspan", "rowspan"],
+    },
+    "TableCaption": {"figcaption": ["data-placeholder"]},
+    "TableCellProperties": {"td": ["class"]},
+    "TableProperties": {"figure": ["class"], "table": ["class"]},
+    "TodoList": {"ul": ["class"], "label": ["class"], "span": ["class"], "li": ["class"], "input": ["class"]},
+    "Underline": {"u": []},
+}
+BLOCKS = {"blockquote", "pre", "div", "figure", "ol", "ul", "p", "table", "tr", "td", "th"}
+
+
+@lru_cache
+def get_allowed_tags(config_name: str) -> Set[str]:
+    """Return the list of allowed HTML tags for a given CKEditor 5 configuration."""
+    return set(get_allowed_attributes(config_name))
+
+
+def get_allowed_attributes(config_name: str) -> Dict[str, Set[str]]:
+    """Return the list of allowed HTML tags and attributes for a given CKEditor 5 configuration."""
+    config = settings.CKEDITOR_5_CONFIGS.get(config_name, {})
+    plugins: Iterable[str] = config.get("plugins", TAGS_BY_PLUGIN.keys())
+    allowed_attributes: Dict[str, Set[str]] = {}
+    for plugin in plugins:
+        for key, attributes in TAGS_BY_PLUGIN.get(plugin, {}).items():
+            if key == BLOCK:
+                keys = BLOCKS
+            else:
+                keys = [key]
+            for key_ in keys:
+                allowed_attributes.setdefault(key_, set())
+                allowed_attributes[key_] |= set(attributes)
+    return allowed_attributes
+
+
+class CKEditor5Field(forms.CharField):
+    """A form field using CKEditor 5 as text editor."""
+
+    default_ckeditor5_config = "default"
+
+    def __init__(self, *args, config_name=None, **kwargs) -> None:
+        """Initialize the field."""
+        self.ckeditor5_config = config_name or self.default_ckeditor5_config
+        self.required_ = kwargs.get("required", True)
+        kwargs["required"] = False
+        css_class = "django_ckeditor_5"
+        self.is_inline_widget = "inline" in self.ckeditor5_config
+        if self.is_inline_widget:
+            css_class += " ck-editor__singleline"
+        kwargs["widget"] = CKEditor5Widget(attrs={"class": css_class}, config_name=self.ckeditor5_config)
+        super().__init__(*args, **kwargs)
+
+    def to_python(self, value):
+        """Convert the value to a string."""
+        allowed_tags = get_allowed_tags(self.ckeditor5_config)
+        allowed_attributes = get_allowed_attributes(self.ckeditor5_config)
+        if value is None:
+            raise ValidationError(self.error_messages["required"], code="required")
+        elif len(value) <= 50 and self.required_:
+            striped = html.unescape(strip_tags(value)).strip()
+            if not striped:
+                raise ValidationError(self.error_messages["required"], code="required")
+        if self.is_inline_widget and "p" in allowed_tags:
+            allowed_tags.remove("p")
+        value = nh3.clean(value, strip_comments=True, tags=allowed_tags, attributes=allowed_attributes)
+        value = autolink_html(value)
+        value = value.replace("\n", " ")
+        return super().to_python(value)
+
+    def prepare_value(self, value):
+        """Prepare the value for the widget."""
+        if value is None:
+            return ""
+        return value
+
+
+class InlineCKEditor5Field(CKEditor5Field):
+    """A form field using CKEditor 5 as inline text editor."""
+
+    default_ckeditor5_config = "inline"
+
+
+class InlineLinkCKEditor5Field(CKEditor5Field):
+    """A form field using CKEditor 5 as inline text editor."""
+
+    default_ckeditor5_config = "inline_link"

df_site/management/__init__.py

@@ -0,0 +1 @@
+"""Management module for df_site."""

df_site/management/commands/__init__.py

@@ -0,0 +1 @@
+"""Some management commands."""

df_site/management/commands/add_image.py

@@ -0,0 +1,104 @@
+"""Add an image to the media storage."""
+
+import pathlib
+
+from django.core.files.storage import Storage, storages
+from django.core.management import BaseCommand
+from django.urls import reverse
+
+from df_site.templatetags.images import AspectPolicy, CachedImage
+
+
+class Command(BaseCommand):
+    """Add an image to the media storage."""
+
+    help = "Add an image to the media storage."
+
+    def add_arguments(self, parser):
+        """Add arguments to the command."""
+        parser.add_argument("path", type=pathlib.Path)
+        parser.add_argument("--storage", choices=["default", "staticfiles"], default="default")
+        parser.add_argument("--name", type=str, default=None)
+        parser.add_argument("--height", type=int, default=None)
+        parser.add_argument("--width", type=int, default=None)
+        parser.add_argument("--format", type=str, default="webp", choices=CachedImage.formats)
+        parser.add_argument("--overwrite", action="store_true", default=False)
+        parser.add_argument("--print", action="store_true", default=False)
+        parser.add_argument(
+            "--policy",
+            type=int,
+            default=AspectPolicy.FORCE_MAX_TRANSPARENT.value,
+            choices=[x.value for x in AspectPolicy],
+        )
+
+    def handle(self, *args, **options):
+        """Add an image to the media storage and generate thumbnails."""
+        aspect_policy = AspectPolicy.get_policy(options["policy"])
+        src_path: pathlib.Path = options["path"]
+        storage: str = options["storage"]
+        name: str = options["name"] or src_path.name
+        # we need to check if the file exists
+        if not src_path.exists():
+            raise FileNotFoundError(f"File {src_path} does not exist.")
+        # we need to check if the file exists in the destination storage
+        storage_obj: Storage = storages[storage]
+        exists = storage_obj.exists(name)
+        cache_engine = "locmem"
+        fmt = options["format"]
+        if exists and not options["overwrite"]:
+            self.stderr.write(f"File {name} already exists in storage {storage}.")
+            return
+        elif exists:
+            storage_obj.delete(name)
+        # we save the file to the destination storage
+        with src_path.open("rb") as src_file:
+            storage_obj.save(name, src_file)
+        #
+        img = CachedImage.from_target_path(f"T/600x600_4/{name}.{fmt}")
+        img.process()
+        self.stdout.write(f"Generated thumbnails: {img.created_sizes}.")
+        if options["print"]:
+            self.stdout.write(img.as_html_tag())
+
+        def url(p):
+            """Return the URL of the thumbnail."""
+            return reverse("thumbnails", kwargs={"path": p})
+
+        img = CachedImage(
+            CachedImage.sources["media"]["src_storage"],
+            CachedImage.sources["media"]["dst_storage"],
+            cache_engine,
+            name,
+            CachedImage.sources["media"]["prefix"],
+            url=url,
+            height=options["height"],
+            width=options["width"],
+            widths=None,
+            aspect_policy=aspect_policy,
+            fmt=fmt,
+            write_thumbnails=True,
+        )
+        img.process()
+        self.stdout.write(f"File {name} saved to storage {storage}.")
+        self.stdout.write(f"Generated thumbnails: {img.created_sizes}.")
+        if options["print"]:
+            self.stdout.write(img.as_html_tag())
+        img = CachedImage(
+            CachedImage.sources["media"]["src_storage"],
+            CachedImage.sources["media"]["dst_storage"],
+            cache_engine,
+            name,
+            CachedImage.sources["media"]["prefix"],
+            url=url,
+            height=options["height"],
+            width=options["width"],
+            widths=[320, 480, 640, 1024, 2048],
+            aspect_policy=aspect_policy,
+            fmt=fmt,
+            write_thumbnails=True,
+        )
+        img.process()
+        self.stdout.write(f"File {name} saved to storage {storage}.")
+        self.stdout.write(f"Generated thumbnails: {img.created_sizes}.")
+        if options["print"]:
+            self.stdout.write(img.as_html_tag())