django-ledger 0.8.2__py3-none-any.whl → 0.8.2.2__py3-none-any.whl

django_ledger/models/chart_of_accounts.py

@@ -39,13 +39,13 @@ roles to create comprehensive financial statements.
 This structure ensures a clear and organized approach to financial management within Django Ledger, facilitating
 accurate record-keeping and reporting.
 """
+
 import warnings
 from random import choices
 from string import ascii_lowercase, digits
 from typing import Optional, Union, Dict
 from uuid import uuid4, UUID
 
-from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.core.exceptions import ValidationError
 from django.db import models
@@ -56,9 +56,16 @@ from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from django_ledger.io import (
-    ROOT_COA, ROOT_GROUP_LEVEL_2, ROOT_GROUP_META, ROOT_ASSETS,
-    ROOT_LIABILITIES, ROOT_CAPITAL,
-    ROOT_INCOME, ROOT_COGS, ROOT_EXPENSES, ROOT_GROUP
+    ROOT_COA,
+    ROOT_GROUP_LEVEL_2,
+    ROOT_GROUP_META,
+    ROOT_ASSETS,
+    ROOT_LIABILITIES,
+    ROOT_CAPITAL,
+    ROOT_INCOME,
+    ROOT_COGS,
+    ROOT_EXPENSES,
+    ROOT_GROUP,
 )
 from django_ledger.models import lazy_loader
 from django_ledger.models.accounts import AccountModel, AccountModelQuerySet
@@ -70,15 +77,12 @@ UserModel = get_user_model()
 
 SLUG_SUFFIX = ascii_lowercase + digits
 
-app_config = apps.get_app_config('django_ledger')
-
 
 class ChartOfAccountsModelValidationError(ValidationError):
     pass
 
 
 class ChartOfAccountModelQuerySet(QuerySet):
-
     def active(self) -> 'ChartOfAccountModelQuerySet':
         """
         QuerySet method to retrieve active items.
@@ -112,12 +116,7 @@ class ChartOfAccountModelQuerySet(QuerySet):
         if user_model.is_superuser:
             return self
 
-        return self.filter(
-            (
-                    Q(entity__admin=user_model) |
-                    Q(entity__managers__in=[user_model])
-            )
-        )
+        return self.filter((Q(entity__admin=user_model) | Q(entity__managers__in=[user_model])))
 
 
 class ChartOfAccountModelManager(Manager):
@@ -128,49 +127,52 @@ class ChartOfAccountModelManager(Manager):
 
     def get_queryset(self) -> ChartOfAccountModelQuerySet:
         qs = ChartOfAccountModelQuerySet(self.model, using=self._db)
-        return qs.annotate(
-            _entity_slug=F('entity__slug'),
-            accountmodel_total__count=Count(
-                'accountmodel',
-                # excludes coa root accounts...
-                filter=Q(accountmodel__depth__gt=2)
-            ),
-            accountmodel_locked__count=Count(
-                'accountmodel',
-                # excludes coa root accounts...
-                filter=Q(accountmodel__depth__gt=2) & Q(accountmodel__locked=True)
-            ),
-            accountmodel_active__count=Count(
-                'accountmodel',
-                # excludes coa root accounts...
-                filter=Q(accountmodel__depth__gt=2) & Q(accountmodel__active=True)
-            ),
-            # Root-group presence and uniqueness checks:
-            accountmodel_rootgroup__count=Count(
-                'accountmodel',
-                filter=Q(accountmodel__role__in=ROOT_GROUP)
-            ),
-            accountmodel_rootgroup_roles__distinct_count=Count(
-                'accountmodel__role',
-                filter=Q(accountmodel__role__in=ROOT_GROUP_META),
-                distinct=True
-            ),
-        ).annotate(
-            configured=models.Case(
-                models.When(
-                    Q(accountmodel_rootgroup__count__gte=1) &
-                    Q(accountmodel_rootgroup__count=F('accountmodel_rootgroup_roles__distinct_count')),
-                    then=Value(True, output_field=BooleanField()),
+        return (
+            qs.annotate(
+                _entity_slug=F('entity__slug'),
+                accountmodel_total__count=Count(
+                    'accountmodel',
+                    # excludes coa root accounts...
+                    filter=Q(accountmodel__depth__gt=2),
+                ),
+                accountmodel_locked__count=Count(
+                    'accountmodel',
+                    # excludes coa root accounts...
+                    filter=Q(accountmodel__depth__gt=2) & Q(accountmodel__locked=True),
+                ),
+                accountmodel_active__count=Count(
+                    'accountmodel',
+                    # excludes coa root accounts...
+                    filter=Q(accountmodel__depth__gt=2) & Q(accountmodel__active=True),
+                ),
+                # Root-group presence and uniqueness checks:
+                accountmodel_rootgroup__count=Count('accountmodel', filter=Q(accountmodel__role__in=ROOT_GROUP)),
+                accountmodel_rootgroup_roles__distinct_count=Count(
+                    'accountmodel__role',
+                    filter=Q(accountmodel__role__in=ROOT_GROUP_META),
+                    distinct=True,
                 ),
-                default=Value(False, output_field=BooleanField()),
-                output_field=BooleanField()
             )
-        ).select_related('entity')
+            .annotate(
+                configured=models.Case(
+                    models.When(
+                        Q(accountmodel_rootgroup__count__gte=1)
+                        & Q(accountmodel_rootgroup__count=F('accountmodel_rootgroup_roles__distinct_count')),
+                        then=Value(True, output_field=BooleanField()),
+                    ),
+                    default=Value(False, output_field=BooleanField()),
+                    output_field=BooleanField(),
+                )
+            )
+            .select_related('entity')
+        )
 
     @deprecated_entity_slug_behavior
-    def for_entity(self,
-                   entity_model: Union['EntityModel | str | UUID'] = None,
-                   **kwargs) -> ChartOfAccountModelQuerySet:
+    def for_entity(
+        self,
+        entity_model: 'Union[EntityModel | str | UUID]' = None,  # noqa: F821
+        **kwargs,  # noqa: F821
+    ) -> ChartOfAccountModelQuerySet:
         """
         Fetches a QuerySet of ChartOfAccountsModel associated with a specific EntityModel & UserModel.
         May pass an instance of EntityModel or a String representing the EntityModel slug.
@@ -195,7 +197,7 @@ class ChartOfAccountModelManager(Manager):
                 'user_model parameter is deprecated and will be removed in a future release. '
                 'Use for_user(user_model).for_entity(entity_model) instead to keep current behavior.',
                 DeprecationWarning,
-                stacklevel=2
+                stacklevel=2,
             )
             if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
                 qs = qs.for_user(kwargs['user_model'])
@@ -232,9 +234,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
     """
 
     uuid = models.UUIDField(default=uuid4, editable=False, primary_key=True)
-    entity = models.ForeignKey('django_ledger.EntityModel',
-                               verbose_name=_('Entity'),
-                               on_delete=models.CASCADE)
+    entity = models.ForeignKey('django_ledger.EntityModel', verbose_name=_('Entity'), on_delete=models.CASCADE)
     active = models.BooleanField(default=True, verbose_name=_('Is Active'))
     description = models.TextField(verbose_name=_('CoA Description'), null=True, blank=True)
     objects = ChartOfAccountModelManager.from_queryset(queryset_class=ChartOfAccountModelQuerySet)()
@@ -244,9 +244,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         ordering = ['-created']
         verbose_name = _('Chart of Account')
         verbose_name_plural = _('Chart of Accounts')
-        indexes = [
-            models.Index(fields=['entity'])
-        ]
+        indexes = [models.Index(fields=['entity'])]
 
     def __str__(self):
         if self.name is not None:
@@ -265,7 +263,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
             return getattr(self, 'configured')
         except AttributeError:
             pass
-        account_qs = self.accountmodel_set.filter(role__in=[ROOT_GROUP])
+        account_qs = self.accountmodel_set.filter(role__in=ROOT_GROUP)
         self.configured = len(account_qs) == len(ROOT_GROUP)
         return self.configured
 
@@ -305,7 +303,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
                     role_default=True,
                     active=False,
                     locked=True,
-                    balance_type=role_meta['balance_type']
+                    balance_type=role_meta['balance_type'],
                 )
                 AccountModel.add_root(instance=root_account)
 
@@ -326,8 +324,9 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
                                 role_default=True,
                                 active=False,
                                 locked=True,
-                                balance_type=role_meta['balance_type']
-                            ))
+                                balance_type=role_meta['balance_type'],
+                            )
+                        )
                 self.configured = True
 
     def get_coa_root_accounts_qs(self) -> AccountModelQuerySet:
@@ -350,10 +349,12 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         qs = self.get_coa_root_accounts_qs()
         return qs.get(role__exact=ROOT_COA)
 
-    def get_account_root_node(self,
-                              account_model: AccountModel,
-                              root_account_qs: Optional[AccountModelQuerySet] = None,
-                              as_queryset: bool = False) -> AccountModel:
+    def get_account_root_node(
+        self,
+        account_model: AccountModel,
+        root_account_qs: Optional[AccountModelQuerySet] = None,
+        as_queryset: bool = False,
+    ) -> AccountModel:
         """
         Fetches the root node of the ChartOfAccountModel instance. The root node is the highest level of the CoA
         hierarchy. It can be used to traverse the hierarchy of the CoA structure downstream.
@@ -389,7 +390,6 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
             self.configure(raise_exception=True)
 
         if not account_model.is_root_account():
-
             if not root_account_qs:
                 root_account_qs = self.get_coa_root_accounts_qs()
 
@@ -406,16 +406,16 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
             elif account_model.is_expense():
                 qs = root_account_qs.filter(code__exact=ROOT_GROUP_META[ROOT_EXPENSES]['code'])
             else:
-                raise ChartOfAccountsModelValidationError(message=f'Unable to locate Balance Sheet'
-                                                                  ' root node for account code: '
-                                                                  f'{account_model.code} {account_model.name}')
+                raise ChartOfAccountsModelValidationError(
+                    message=f'Unable to locate Balance Sheet'
+                    ' root node for account code: '
+                    f'{account_model.code} {account_model.name}'
+                )
             if as_queryset:
                 return qs
             return qs.get()
 
-        raise ChartOfAccountsModelValidationError(
-            message='Adding Root account to Chart of Accounts is not allowed.'
-        )
+        raise ChartOfAccountsModelValidationError(message='Adding Root account to Chart of Accounts is not allowed.')
 
     def get_non_root_coa_accounts_qs(self) -> AccountModelQuerySet:
         """
@@ -486,19 +486,12 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         """
         if self.slug:
             if raise_exception:
-                raise ChartOfAccountsModelValidationError(
-                    message=_(f'CoA {self.uuid} already has a slug')
-                )
+                raise ChartOfAccountsModelValidationError(message=_(f'CoA {self.uuid} already has a slug'))
             return
         self.slug = f'coa-{self.entity.slug[-5:]}-' + ''.join(choices(SLUG_SUFFIX, k=15))
 
         if commit:
-            self.save(
-                update_fields=[
-                    'slug',
-                    'updated'
-                ]
-            )
+            self.save(update_fields=['slug', 'updated'])
 
     def is_default(self) -> bool:
         """
@@ -540,18 +533,16 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
 
         """
         if not isinstance(account_model_qs, AccountModelQuerySet):
-            raise ChartOfAccountsModelValidationError(
-                message='Must pass an instance of AccountModelQuerySet'
-            )
+            raise ChartOfAccountsModelValidationError(message='Must pass an instance of AccountModelQuerySet')
         for acc_model in account_model_qs:
             if not acc_model.coa_model_id == self.uuid:
-                raise ChartOfAccountsModelValidationError(
-                    message=f'Invalid root queryset for CoA {self.name}'
-                )
+                raise ChartOfAccountsModelValidationError(message=f'Invalid root queryset for CoA {self.name}')
 
-    def insert_account(self,
-                       account_model: AccountModel,
-                       root_account_qs: Optional[AccountModelQuerySet] = None):
+    def insert_account(
+        self,
+        account_model: AccountModel,
+        root_account_qs: Optional[AccountModelQuerySet] = None,
+    ):
         """
         This method inserts the given account model into the chart of accounts (COA) instance.
         It first verifies if the account model's COA model ID matches the COA's UUID. If not, it
@@ -599,21 +590,22 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
             self.validate_account_model_qs(root_account_qs)
 
         account_root_node: AccountModel = self.get_account_root_node(
-            account_model=account_model,
-            root_account_qs=root_account_qs
+            account_model=account_model, root_account_qs=root_account_qs
         )
 
         account_root_node.add_child(instance=account_model)
         coa_accounts_qs = self.get_non_root_coa_accounts_qs()
         return coa_accounts_qs.get(uuid__exact=account_model.uuid)
 
-    def create_account(self,
-                       code: str,
-                       role: str,
-                       name: str,
-                       balance_type: str,
-                       active: bool,
-                       root_account_qs: Optional[AccountModelQuerySet] = None):
+    def create_account(
+        self,
+        code: str,
+        role: str,
+        name: str,
+        balance_type: str,
+        active: bool,
+        root_account_qs: Optional[AccountModelQuerySet] = None,
+    ):
         """
         Proper method for inserting a new Account Model into a CoA.
         Use this in liu of the direct instantiation of the AccountModel of using the django related manager.
@@ -644,14 +636,11 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
             role=role,
             active=active,
             balance_type=balance_type,
-            coa_model=self
+            coa_model=self,
         )
         account_model.clean()
 
-        account_model = self.insert_account(
-            account_model=account_model,
-            root_account_qs=root_account_qs
-        )
+        account_model = self.insert_account(account_model=account_model, root_account_qs=root_account_qs)
         return account_model
 
     # ACTIONS -----
@@ -692,18 +681,10 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         self.entity.default_coa_id = self.uuid
         self.clean()
         if commit:
-            self.entity.save(
-                update_fields=[
-                    'default_coa_id',
-                    'updated'
-                ]
-            )
+            self.entity.save(update_fields=['default_coa_id', 'updated'])
 
     def can_mark_as_default(self):
-        return all([
-            self.is_active(),
-            not self.is_default()
-        ])
+        return all([self.is_active(), not self.is_default()])
 
     def can_activate(self) -> bool:
         """
@@ -723,10 +704,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         -------
             True if the object can be deactivated, False otherwise.
         """
-        return all([
-            self.is_active(),
-            not self.is_default()
-        ])
+        return all([self.is_active(), not self.is_default()])
 
     def mark_as_active(self, commit: bool = False, raise_exception: bool = False, **kwargs):
         """
@@ -741,19 +719,13 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         """
         if self.is_active():
             if raise_exception:
-                raise ChartOfAccountsModelValidationError(
-                    message=_('The Chart of Accounts is currently active.')
-                )
+                raise ChartOfAccountsModelValidationError(message=_('The Chart of Accounts is currently active.'))
             return
 
         self.active = True
         self.clean()
         if commit:
-            self.save(
-                update_fields=[
-                    'active',
-                    'updated'
-                ])
+            self.save(update_fields=['active', 'updated'])
 
     def mark_as_inactive(self, commit: bool = False, raise_exception: bool = False, **kwargs):
         """
@@ -768,19 +740,13 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         """
         if not self.is_active():
             if raise_exception:
-                raise ChartOfAccountsModelValidationError(
-                    message=_('The Chart of Accounts is currently not active.')
-                )
+                raise ChartOfAccountsModelValidationError(message=_('The Chart of Accounts is currently not active.'))
             return
 
         self.active = False
         self.clean()
         if commit:
-            self.save(
-                update_fields=[
-                    'active',
-                    'updated'
-                ])
+            self.save(update_fields=['active', 'updated'])
 
     # URLS....
     def mark_as_default_url(self) -> str:
@@ -794,10 +760,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         """
         return reverse(
             viewname='django_ledger:coa-action-mark-as-default',
-            kwargs={
-                'entity_slug': self.entity_slug,
-                'coa_slug': self.slug
-            }
+            kwargs={'entity_slug': self.entity_slug, 'coa_slug': self.slug},
         )
 
     def mark_as_active_url(self) -> str:
@@ -811,10 +774,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         """
         return reverse(
             viewname='django_ledger:coa-action-mark-as-active',
-            kwargs={
-                'entity_slug': self.entity_slug,
-                'coa_slug': self.slug
-            }
+            kwargs={'entity_slug': self.entity_slug, 'coa_slug': self.slug},
         )
 
     def mark_as_inactive_url(self) -> str:
@@ -828,74 +788,49 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         """
         return reverse(
             viewname='django_ledger:coa-action-mark-as-inactive',
-            kwargs={
-                'entity_slug': self.entity_slug,
-                'coa_slug': self.slug
-            }
+            kwargs={'entity_slug': self.entity_slug, 'coa_slug': self.slug},
         )
 
     def get_coa_list_url(self):
-        return reverse(
-            viewname='django_ledger:coa-list',
-            kwargs={
-                'entity_slug': self.entity_slug
-            }
-        )
+        return reverse(viewname='django_ledger:coa-list', kwargs={'entity_slug': self.entity_slug})
 
     def get_coa_list_inactive_url(self):
         return reverse(
             viewname='django_ledger:coa-list-inactive',
-            kwargs={
-                'entity_slug': self.entity_slug
-            }
+            kwargs={'entity_slug': self.entity_slug},
         )
 
     def get_coa_create_url(self):
         return reverse(
             viewname='django_ledger:coa-create',
-            kwargs={
-                'entity_slug': self.entity_slug
-            }
+            kwargs={'entity_slug': self.entity_slug},
         )
 
     def get_absolute_url(self) -> str:
         return reverse(
             viewname='django_ledger:coa-detail',
-            kwargs={
-                'entity_slug': self.entity_slug,
-                'coa_slug': self.slug
-            }
+            kwargs={'entity_slug': self.entity_slug, 'coa_slug': self.slug},
         )
 
     def get_update_url(self) -> str:
         return reverse(
             viewname='django_ledger:coa-update',
-            kwargs={
-                'entity_slug': self.entity_slug,
-                'coa_slug': self.slug
-            }
+            kwargs={'entity_slug': self.entity_slug, 'coa_slug': self.slug},
         )
 
     def get_account_list_url(self):
-
         if not self.slug:
             self.generate_slug(commit=True)
 
         return reverse(
             viewname='django_ledger:account-list',
-            kwargs={
-                'entity_slug': self.entity_slug,
-                'coa_slug': self.slug
-            }
+            kwargs={'entity_slug': self.entity_slug, 'coa_slug': self.slug},
         )
 
     def get_create_coa_account_url(self):
         return reverse(
             viewname='django_ledger:account-create',
-            kwargs={
-                'coa_slug': self.slug,
-                'entity_slug': self.entity_slug
-            }
+            kwargs={'coa_slug': self.slug, 'entity_slug': self.entity_slug},
         )
 
     def clean(self):
@@ -915,9 +850,7 @@ class ChartOfAccountModel(ChartOfAccountModelAbstract):
 def chartofaccountsmodel_presave(instance: ChartOfAccountModelAbstract, **kwargs):
     instance.generate_slug()
     if instance.is_default() and not instance.active:
-        raise ChartOfAccountsModelValidationError(
-            _('Default Chart of Accounts cannot be deactivated.')
-        )
+        raise ChartOfAccountsModelValidationError(_('Default Chart of Accounts cannot be deactivated.'))
 
 
 @receiver(post_save, sender=ChartOfAccountModel)

django_ledger/models/coa_default.py

@@ -109,6 +109,7 @@ Default Chart of Accounts Table
   4050  in_other                    credit          Other Income                                                   root_income
   4020  in_passive                  credit          Investing Income                                               root_income
   2010  lia_cl_acc_payable          credit          Accounts Payable                                               root_liabilities
+  2015  lia_cl_credit_line          credit          Accounts Payable                                               root_liabilities
   2060  lia_cl_def_rev              credit          Deferred Revenues                                              root_liabilities
   2030  lia_cl_int_payable          credit          Interest Payable                                               root_liabilities
   2050  lia_cl_ltd_mat              credit          Current Maturities LT Debt                                     root_liabilities

django_ledger/models/customer.py

@@ -54,7 +54,7 @@ class CustomerModelQueryset(QuerySet):
     reports.
     """
 
-    def for_user(self, user_model):
+    def for_user(self, user_model) -> 'CustomerModelQueryset':
         """
         Fetches a QuerySet of BillModels that the UserModel as access to.
         May include BillModels from multiple Entities.
@@ -70,12 +70,9 @@ class CustomerModelQueryset(QuerySet):
         """
         if user_model.is_superuser:
             return self
-        return self.filter(
-            Q(entity_model__admin=user_model)
-            | Q(entity_model__managers__in=[user_model])
-        )
+        return self.filter(Q(entity_model__admin=user_model) | Q(entity_model__managers__in=[user_model]))
 
-    def active(self) -> QuerySet:
+    def active(self) -> 'CustomerModelQueryset':
         """
         Active customers can be assigned to new Invoices and show on dropdown menus and views.
 
@@ -86,7 +83,7 @@ class CustomerModelQueryset(QuerySet):
         """
         return self.filter(active=True)
 
-    def inactive(self) -> QuerySet:
+    def inactive(self) -> 'CustomerModelQueryset':
         """
         Active customers can be assigned to new Invoices and show on dropdown menus and views.
         Marking CustomerModels as inactive can help reduce Database load to populate select inputs and also inactivate
@@ -100,7 +97,7 @@ class CustomerModelQueryset(QuerySet):
         """
         return self.filter(active=False)
 
-    def hidden(self) -> QuerySet:
+    def hidden(self) -> 'CustomerModelQueryset':
         """
         Hidden customers do not show on dropdown menus, but may be used via APIs or any other method that does not
         involve the UI.
@@ -112,7 +109,7 @@ class CustomerModelQueryset(QuerySet):
         """
         return self.filter(hidden=True)
 
-    def visible(self) -> QuerySet:
+    def visible(self) -> 'CustomerModelQueryset':
         """
         Visible customers show on dropdown menus and views. Visible customers are active and not hidden.
 
@@ -130,10 +127,11 @@ class CustomerModelManager(Manager):
     CustomerModel.
     """
 
+    def get_queryset(self) -> CustomerModelQueryset:
+        return CustomerModelQueryset(self.model, using=self._db)
+
     @deprecated_entity_slug_behavior
-    def for_entity(
-        self, entity_model: 'EntityModel | str | UUID' = None, **kwargs
-    ) -> CustomerModelQueryset:
+    def for_entity(self, entity_model: 'EntityModel | str | UUID', **kwargs) -> CustomerModelQueryset:  # noqa: F821
         """
         Fetches a QuerySet of CustomerModel associated with a specific EntityModel & UserModel.
         May pass an instance of EntityModel or a String representing the EntityModel slug.
@@ -161,16 +159,15 @@ class CustomerModelManager(Manager):
                 qs = qs.for_user(kwargs['user_model'])
 
         if isinstance(entity_model, EntityModel):
-            qs = qs.filter(entity_model=entity_model)
+            return qs.filter(entity_model=entity_model)
         elif isinstance(entity_model, str):
-            qs = qs.filter(entity_model__slug__exact=entity_model)
+            return qs.filter(entity_model__slug__exact=entity_model)
         elif isinstance(entity_model, UUID):
-            qs = qs.filter(entity_model_id=entity_model)
+            return qs.filter(entity_model_id=entity_model)
         else:
             raise CustomerModelValidationError(
                 message='Must pass EntityModel, slug or EntityModel UUID',
             )
-        return qs
 
 
 class CustomerModelAbstract(ContactInfoMixIn, TaxCollectionMixIn, CreateUpdateMixIn):
@@ -232,9 +229,7 @@ class CustomerModelAbstract(ContactInfoMixIn, TaxCollectionMixIn, CreateUpdateMi
     description = models.TextField()
     active = models.BooleanField(default=True)
     hidden = models.BooleanField(default=False)
-    picture = models.ImageField(
-        upload_to=customer_picture_upload_to, null=True, blank=True
-    )
+    picture = models.ImageField(upload_to=customer_picture_upload_to, null=True, blank=True)
 
     additional_info = models.JSONField(null=True, blank=True, default=dict)
 
@@ -292,9 +287,7 @@ class CustomerModelAbstract(ContactInfoMixIn, TaxCollectionMixIn, CreateUpdateMi
                 'key__exact': EntityStateModel.KEY_CUSTOMER,
             }
 
-            state_model_qs = EntityStateModel.objects.filter(
-                **LOOKUP
-            ).select_for_update()
+            state_model_qs = EntityStateModel.objects.filter(**LOOKUP).select_for_update()
             state_model = state_model_qs.get()
             state_model.sequence = F('sequence') + 1
             state_model.save()
@@ -344,11 +337,9 @@ class CustomerModelAbstract(ContactInfoMixIn, TaxCollectionMixIn, CreateUpdateMi
 
         return self.customer_number
 
-    def validate_for_entity(self, entity_model: 'EntityModel'):
+    def validate_for_entity(self, entity_model: 'EntityModel'):  # noqa: F821
         if entity_model.uuid != self.entity_model_id:
-            raise CustomerModelValidationError(
-                'EntityModel does not belong to this Vendor'
-            )
+            raise CustomerModelValidationError('EntityModel does not belong to this Vendor')
 
     def clean(self):
         """