django-siteflags 1.3.1__py3-none-any.whl

django_siteflags-1.3.1.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.5
+Name: django-siteflags
+Version: 1.3.1
+Summary: Reusable application for Django allowing users to flag/bookmark site objects
+Project-URL: Homepage, https://github.com/idlesign/django-siteflags
+Project-URL: Documentation, https://django-siteflags.readthedocs.io/
+Author-email: Igor Starikov <idlesign@yandex.ru>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: Django,bookmarks,flags
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: django-etc>=1.2.0
+Description-Content-Type: text/markdown
+
+# django-siteflags
+
+<https://github.com/idlesign/django-siteflags>
+
+[![release](https://img.shields.io/pypi/v/django-siteflags.svg)](https://pypi.python.org/pypi/django-siteflags)
+[![lic](https://img.shields.io/pypi/l/django-siteflags.svg)](https://pypi.python.org/pypi/django-siteflags)
+[![coverage](https://img.shields.io/coveralls/idlesign/django-siteflags/master.svg)](https://coveralls.io/r/idlesign/django-siteflags)
+
+## Description
+
+*Reusable application for Django allowing users to flag/bookmark site objects*
+
+So you want a user to be able to put some flags on certain site entities.
+
+Let's say you need a kind of bookmark powered service, or a site where content is flagged and moderated,
+or a simplified rating system, or something similar.
+
+Inherit you model from `siteflags.models.ModelWithFlag` and you're almost done.
+
+Like that:
+
+```python
+# myapp/models.py
+from siteflags.models import ModelWithFlag
+
+
+class Article(ModelWithFlag):
+
+    ...  # Some model fields here.
+```
+
+And like so:
+
+```python
+# myapp/views.py
+from django.shortcuts import get_object_or_404
+from .models import Article
+
+
+def article_details(request, article_id):
+
+    article = get_object_or_404(Article, pk=article_id)
+
+    user = request.user
+    article.set_flag(user)
+    article.is_flagged(user)
+    article.remove_flag(user)
+
+    ...
+```
+
+Quite simple. Quite generic. Read the documentation.
+
+## Documentation
+
+<https://django-siteflags.readthedocs.io/>

django_siteflags-1.3.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+siteflags/__init__.py,sha256=LhfcrliOSRBaoBG63tAozrhVePp8WjbNdR8v8M6Nriw,74
+siteflags/admin.py,sha256=nktGm6rQCPltJ-eo80yHHk4v6imbmpNytpzyH_7cO70,553
+siteflags/apps.py,sha256=8_Vp500cVWsSDGCPov8tRhtPBLrRqZYL9oYv4JJMY14,273
+siteflags/models.py,sha256=Qt4-l2eYBXoSughKCsFTsmzRk5-9BSQbxSQMef48p7E,10587
+siteflags/settings.py,sha256=_P-eurszeYAXp4cr10CfSW3Na7fWVAThL5Lomf0NYdY,173
+siteflags/utils.py,sha256=luwjqlIyXVVXFIvoU83kBUHib8ibp6T2OAYxDqkMns4,330
+siteflags/locale/empty,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siteflags/locale/en/LC_MESSAGES/django.po,sha256=vGGulGisJaGjzwrDwXeOtuFagzn5syNRSq0_RicR8JU,969
+siteflags/locale/ru/LC_MESSAGES/django.mo,sha256=0Sxep1PgIo1df4_rWs1QcrnNX8cGImsw_h8ovDipyu4,1028
+siteflags/locale/ru/LC_MESSAGES/django.po,sha256=5K19uYUaIoTh2sZFwtjfr3V_Sv9NFSn3fbBqzq1kisU,1376
+siteflags/migrations/0001_initial.py,sha256=5E04N8Uyogd4197fmMFXeLi8nWW-OenEI1Twe1n8JSo,1633
+siteflags/migrations/0002_alter_flag_content_type_alter_flag_user.py,sha256=AMuQWe8V-cXQANcLS7T_avUt30lP2aC2MX_ulmSpiKU,972
+siteflags/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_siteflags-1.3.1.dist-info/METADATA,sha256=Nb2q8NV1CWCT8JCtXiW9mmrFiJPxMbF5mhmszm7pKto,2585
+django_siteflags-1.3.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+django_siteflags-1.3.1.dist-info/licenses/LICENSE,sha256=8VxXkHRjdSGZbcDPHxL73V2tdQdhLnyka9u45l2FAl8,1508
+django_siteflags-1.3.1.dist-info/RECORD,,

django_siteflags-1.3.1.dist-info/WHEEL

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

django_siteflags-1.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2014-2026, Igor `idle sign` Starikov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the django-siteflags nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

siteflags/__init__.py

@@ -0,0 +1,4 @@
+VERSION = '1.3.1'
+
+
+default_app_config = 'siteflags.apps.SiteflagsConfig'

siteflags/admin.py

@@ -0,0 +1,34 @@
+from django.contrib import admin
+
+from .utils import get_flag_model
+
+FLAG_MODEL = get_flag_model()
+
+
+@admin.register(FLAG_MODEL)
+class FlagModelAdmin(admin.ModelAdmin):
+
+    list_display = (
+        'time_created',
+        'content_type',
+        'object_id',
+        'status',
+    )
+
+    search_fields = (
+        'object_id',
+        'content_type',
+        'user',
+    )
+
+    list_filter = (
+        'time_created',
+        'status',
+        'content_type',
+    )
+
+    ordering = (
+        '-time_created',
+    )
+
+    date_hierarchy = 'time_created'

siteflags/apps.py

@@ -0,0 +1,10 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class SiteflagsConfig(AppConfig):
+    """Siteflags configuration."""
+
+    name = 'siteflags'
+    verbose_name = _('Site Flags')
+    default_auto_field = 'django.db.models.AutoField'

siteflags/locale/en/LC_MESSAGES/django.po

@@ -0,0 +1,54 @@
+# 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.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-09-08 14:33+0700\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: config.py:9
+msgid "Site Flags"
+msgstr ""
+
+#: models.py:28
+msgid "Note"
+msgstr ""
+
+#: models.py:29
+msgid "Status"
+msgstr ""
+
+#: models.py:31
+msgid "User"
+msgstr ""
+
+#: models.py:32
+msgid "Date created"
+msgstr ""
+
+#: models.py:35
+msgid "Object ID"
+msgstr ""
+
+#: models.py:36
+msgid "Content type"
+msgstr ""
+
+#: models.py:42
+msgid "Flag"
+msgstr ""
+
+#: models.py:43
+msgid "Flags"
+msgstr ""

siteflags/locale/ru/LC_MESSAGES/django.po

@@ -0,0 +1,58 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+#
+# Translators:
+# Igor Starikov <idlesign@yandex.ru>, 2014
+msgid ""
+msgstr ""
+"Project-Id-Version: django-siteflags\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-09-08 14:33+0700\n"
+"PO-Revision-Date: 2014-09-08 14:35+0700\n"
+"Last-Translator: Igor 'idle sign' Starikov <idlesign@yandex.ru>\n"
+"Language-Team: Russian (http://www.transifex.com/projects/p/django-siteflags/"
+"language/ru/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: ru\n"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
+"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
+"X-Generator: Poedit 1.5.4\n"
+
+#: config.py:9
+msgid "Site Flags"
+msgstr "Флаги сайта"
+
+#: models.py:28
+msgid "Note"
+msgstr "Заметка"
+
+#: models.py:29
+msgid "Status"
+msgstr "Статус"
+
+#: models.py:31
+msgid "User"
+msgstr "Пользователь"
+
+#: models.py:32
+msgid "Date created"
+msgstr "Дата создания"
+
+#: models.py:35
+msgid "Object ID"
+msgstr "ID объекта"
+
+#: models.py:36
+msgid "Content type"
+msgstr "Тип содержимого"
+
+#: models.py:42
+msgid "Flag"
+msgstr "Флаг"
+
+#: models.py:43
+msgid "Flags"
+msgstr "Флаги"

siteflags/migrations/0001_initial.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+from django.conf import settings
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('contenttypes', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Flag',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('note', models.TextField(verbose_name='Note', blank=True)),
+                ('status', models.IntegerField(db_index=True, null=True, verbose_name='Status', blank=True)),
+                ('time_created', models.DateTimeField(auto_now_add=True, verbose_name='Date created')),
+                ('object_id', models.PositiveIntegerField(verbose_name='Object ID', db_index=True)),
+                ('content_type', models.ForeignKey(related_name='siteflags_flag_flags', verbose_name='Content type', to='contenttypes.ContentType', on_delete=models.CASCADE)),
+                ('user', models.ForeignKey(related_name='flag_users', verbose_name='User', to=settings.AUTH_USER_MODEL, on_delete=models.CASCADE)),
+            ],
+            options={
+                'abstract': False,
+                'verbose_name': 'Flag',
+                'verbose_name_plural': 'Flags',
+            },
+            bases=(models.Model,),
+        ),
+        migrations.AlterUniqueTogether(
+            name='flag',
+            unique_together=set([('content_type', 'object_id', 'user', 'status')]),
+        ),
+    ]

siteflags/migrations/0002_alter_flag_content_type_alter_flag_user.py

@@ -0,0 +1,27 @@
+# Generated by Django 6.1.3 on 2026-11-10 07:51
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        ('siteflags', '0001_initial'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='flag',
+            name='content_type',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='%(app_label)s_%(class)s_flags', to='contenttypes.contenttype', verbose_name='Content type'),
+        ),
+        migrations.AlterField(
+            model_name='flag',
+            name='user',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_users', to=settings.AUTH_USER_MODEL, verbose_name='User'),
+        ),
+    ]

siteflags/models.py

@@ -0,0 +1,345 @@
+from collections import defaultdict
+from typing import List, Type, Dict, Union, Tuple, Optional
+from collections.abc import Sequence
+
+from django.conf import settings
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
+from django.contrib.contenttypes.models import ContentType
+from django.db import models, IntegrityError
+from django.db.models.query import QuerySet
+from django.utils.translation import gettext_lazy as _
+from etc.toolbox import get_model_class_from_string
+
+from .settings import MODEL_FLAG
+from .utils import get_flag_model
+
+if False:  # pragma: nocover
+    from django.contrib.auth.models import User  # noqa
+
+USER_MODEL = getattr(settings, 'AUTH_USER_MODEL', 'auth.User')
+
+TypeFlagsForType = list['FlagBase']
+TypeFlagsForTypes = dict[type[models.Model], TypeFlagsForType]
+
+
+class FlagBase(models.Model):
+    """Base class for flag models.
+    Flags are marks on various site entities (model instances).
+
+    Inherit from this model and override SITEFLAGS_FLAG_MODEL in settings.py
+    to customize model fields and behaviour.
+
+    """
+    note = models.TextField(_('Note'), blank=True)
+    status = models.IntegerField(_('Status'), null=True, blank=True, db_index=True)
+
+    user = models.ForeignKey(
+        USER_MODEL, related_name='%(class)s_users', verbose_name=_('User'),
+        on_delete=models.CASCADE)
+
+    time_created = models.DateTimeField(_('Date created'), auto_now_add=True)
+
+    # Here follows a link to an object.
+    object_id = models.PositiveIntegerField(verbose_name=_('Object ID'), db_index=True)
+
+    content_type = models.ForeignKey(
+        ContentType, verbose_name=_('Content type'),
+        related_name='%(app_label)s_%(class)s_flags',
+        on_delete=models.CASCADE)
+
+    linked_object = GenericForeignKey()
+
+    class Meta:
+
+        abstract = True
+
+        verbose_name = _('Flag')
+        verbose_name_plural = _('Flags')
+
+        unique_together = (
+            'content_type',
+            'object_id',
+            'user',
+            'status',
+        )
+
+    @classmethod
+    def get_flags_for_types(
+            cls,
+            mdl_classes: list[type[models.Model]],
+            *,
+            user: 'User' = None,
+            status: int = None,
+            allow_empty: bool = True,
+            with_objects: bool = False,
+
+    ) -> TypeFlagsForTypes:
+        """Returns a dictionary with flag objects associated with the given model classes (types).
+        The dictionary is indexed by model classes.
+        Each dict entry contains a list of associated flags.
+
+        :param mdl_classes: Types to get flags for.
+        :param user: User filter,
+        :param status: Status filter
+        :param allow_empty: Flag. Include results for all given types, even those without associated flags.
+        :param with_objects: Whether to fetch the flagged objects along with the flags.
+
+        """
+        if not mdl_classes or (user and not user.id):
+            return {}
+
+        types_for_models = ContentType.objects.get_for_models(*mdl_classes, for_concrete_models=False)
+        filter_kwargs = {'content_type__in': types_for_models.values()}
+        update_filter_dict(filter_kwargs, user=user, status=status)
+
+        flags = cls.objects.filter(**filter_kwargs)
+
+        if with_objects:
+            flags = flags.prefetch_related('linked_object')
+
+        flags = flags.order_by('-time_created')
+
+        flags_dict = defaultdict(list)
+
+        for flag in flags:
+            flags_dict[flag.content_type_id].append(flag)
+
+        result = {}  # Respect initial order.
+
+        for mdl_cls in mdl_classes:
+
+            content_type_id = types_for_models[mdl_cls].id
+
+            if content_type_id in flags_dict:
+                result[mdl_cls] = flags_dict[content_type_id]
+
+            elif allow_empty:
+                result[mdl_cls] = []
+
+        return result
+
+    @classmethod
+    def get_flags_for_objects(
+            cls,
+            objects_list: Union[QuerySet, Sequence],
+            *,
+            user: 'User' = None,
+            status: int = None
+
+    ) -> dict[int, TypeFlagsForType]:
+        """Returns a dictionary with flag objects associated with the given model objects.
+        The dictionary is indexed by objects IDs.
+        Each dict entry contains a list of associated flag objects.
+
+        :param objects_list:
+        :param user:
+        :param status:
+
+        """
+        if not objects_list or (user and not user.id):
+            return {}
+
+        objects_ids = objects_list
+        if not isinstance(objects_list, QuerySet):
+            objects_ids = [obj.pk for obj in objects_list]
+
+        filter_kwargs = {
+            'object_id__in': objects_ids,
+            # Consider this list homogeneous.
+            'content_type': ContentType.objects.get_for_model(objects_list[0], for_concrete_model=False)
+        }
+        update_filter_dict(filter_kwargs, user=user, status=status)
+
+        flags = cls.objects.filter(**filter_kwargs)
+        flags_dict = defaultdict(list)
+
+        for flag in flags:
+            flags_dict[flag.object_id].append(flag)
+
+        result = {}
+
+        for obj in objects_list:
+            result[obj.pk] = flags_dict.get(obj.pk, [])
+
+        return result
+
+    def __str__(self):
+        return f'{self.content_type}:{self.object_id} status {self.status}'
+
+
+class Flag(FlagBase):
+    """Built-in flag class. Default functionality."""
+
+
+class ModelWithFlag(models.Model):
+    """Helper base class for models with flags.
+
+    Inherit from this model to be able to mark model instances.
+
+    """
+    flags = GenericRelation(MODEL_FLAG)
+
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def get_flags_for_type(
+            cls,
+            mdl_classes: list[type[models.Model]] = None,
+            *,
+            user: 'User' = None,
+            status: int = None,
+            allow_empty: bool = True,
+            with_objects: bool = False,
+
+    ) -> Union[TypeFlagsForTypes, TypeFlagsForType]:
+        """Returns a dictionary with flag objects associated with
+        the given model classes (types) if mdl_classes is given.
+        The dictionary is indexed by model classes.
+        Each dict entry contains a list of associated flag objects.
+
+        If mdl_classes is not given, returns a list of associated
+        flag objects for this very class.
+
+        :param mdl_classes: Types to get flags for. If not set the current class is used.
+        :param user: User filter,
+        :param status: Status filter
+        :param allow_empty: Flag. Include results for all given types, even those without associated flags.
+        :param with_objects: Whether to fetch the flagged objects along with the flags.
+
+        """
+        model: FlagBase = get_model_class_from_string(MODEL_FLAG)
+
+        single_type = False
+        if mdl_classes is None:
+            mdl_classes = [cls]
+            single_type = True
+            allow_empty = True
+
+        result = model.get_flags_for_types(
+            mdl_classes,
+            user=user,
+            status=status,
+            allow_empty=allow_empty,
+            with_objects=with_objects,
+        )
+
+        if single_type:
+            result = result[cls]
+
+        return result
+
+    get_flags_for_types = get_flags_for_type  # alias
+
+    @classmethod
+    def get_flags_for_objects(
+            cls,
+            objects_list: Union[QuerySet, Sequence],
+            *,
+            user: 'User' = None,
+            status: int = None
+
+    ) -> dict[int, TypeFlagsForType]:
+        """Returns a dictionary with flag objects associated with the given model objects.
+        The dictionary is indexed by objects IDs.
+        Each dict entry contains a list of associated flag objects.
+
+        :param objects_list:
+        :param user:
+        :param status:
+
+        """
+        model: FlagBase = get_model_class_from_string(MODEL_FLAG)
+        return model.get_flags_for_objects(objects_list, user=user, status=status)
+
+    def get_flags(self, user: 'User' = None, *, status: int = None) -> Union[QuerySet, Sequence[FlagBase]]:
+        """Returns flags for the object optionally filtered by status.
+
+        :param user: Optional user filter
+        :param status: Optional status filter
+
+        """
+        filter_kwargs = {}
+        update_filter_dict(filter_kwargs, user=user, status=status)
+        return self.flags.filter(**filter_kwargs).all()
+
+    def set_flag(self, user: 'User', *, note: str = None, status: int = None) -> FlagBase | None:
+        """Flags the object.
+
+        :param user:
+        :param note: User-defined note for this flag.
+        :param status: Optional status integer (the meaning is defined by a developer).
+
+        """
+        if not user.id:
+            return None
+
+        init_kwargs = {
+            'user': user,
+            'linked_object': self,
+        }
+        if note is not None:
+            init_kwargs['note'] = note
+
+        if status is not None:
+            init_kwargs['status'] = status
+
+        flag = get_flag_model()(**init_kwargs)
+
+        try:
+            flag.save()
+
+        except IntegrityError:  # Record already exists.
+            return None
+
+        return flag
+
+    def remove_flag(self, user: 'User' = None, *, status: int = None):
+        """Removes flag(s) from the object.
+
+        :param user: Optional user filter
+        :param status: Optional status filter
+
+        """
+        filter_kwargs = {
+            'content_type': ContentType.objects.get_for_model(self),
+            'object_id': self.id
+        }
+        update_filter_dict(filter_kwargs, user=user, status=status)
+        get_flag_model().objects.filter(**filter_kwargs).delete()
+
+    def is_flagged(self, user: 'User' = None, *, status: int = None) -> int:
+        """Returns a number of times the object is flagged by a user.
+
+        :param user: Optional user filter
+        :param status: Optional status filter
+
+        """
+        if user and user.is_anonymous:
+            return False
+
+        filter_kwargs = {
+            'content_type': ContentType.objects.get_for_model(self),
+            'object_id': self.id,
+        }
+        update_filter_dict(filter_kwargs, user=user, status=status)
+        return self.flags.filter(**filter_kwargs).count()
+
+
+def update_filter_dict(d: dict, *, user: Optional['User'], status: int | None):
+    """Helper. Updates filter dict for a queryset.
+
+    :param d:
+    :param user:
+    :param status:
+
+    """
+    if user is not None:
+
+        if not user.id:
+            return None
+
+        d['user'] = user
+
+    if status is not None:
+        d['status'] = status

siteflags/settings.py

@@ -0,0 +1,5 @@
+from django.conf import settings
+
+
+MODEL_FLAG = getattr(settings, 'SITEFLAGS_FLAG_MODEL', 'siteflags.Flag')
+"""Dotted path to a Flag custom model in form of `app.Model`."""

siteflags/utils.py

@@ -0,0 +1,13 @@
+from typing import Type
+
+from etc.toolbox import get_model_class_from_settings
+
+from siteflags import settings
+
+if False:  # pragma: nocover
+    from .models import Flag
+
+
+def get_flag_model() -> type['Flag']:
+    """Returns the Flag model, set for the project."""
+    return get_model_class_from_settings(settings, 'MODEL_FLAG')