django-ledger 0.7.11__py3-none-any.whl → 0.8.1__py3-none-any.whl

django_ledger/models/entity.py

@@ -17,6 +17,7 @@ EntityModels may also have different financial reporting periods, (also known as
 specified at the time of creation. All key functionality around the Fiscal Year is encapsulated in the
 EntityReportMixIn.
 """
+
 from calendar import monthrange
 from collections import defaultdict
 from datetime import date, datetime, timedelta
@@ -24,36 +25,56 @@ from decimal import Decimal
 from itertools import zip_longest
 from random import choices
 from string import ascii_lowercase, digits
-from typing import Tuple, Union, Optional, List, Dict, Set
-from uuid import uuid4, UUID
+from typing import Dict, List, Optional, Set, Tuple, Union
+from uuid import UUID, uuid4
 
 from django.contrib.auth import get_user_model
 from django.core import serializers
 from django.core.cache import caches
-from django.core.exceptions import ValidationError, ObjectDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models
-from django.db.models import Q, F, Model
+from django.db.models import F, Model, Q
 from django.db.models.signals import pre_save
 from django.urls import reverse
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
 from treebeard.mp_tree import MP_Node, MP_NodeManager, MP_NodeQuerySet
 
-from django_ledger.io import roles as roles_module, validate_roles, IODigestContextManager
-from django_ledger.io.io_core import IOMixIn, get_localtime, get_localdate
-from django_ledger.models.accounts import AccountModel, AccountModelQuerySet, DEBIT, CREDIT
-from django_ledger.models.bank_account import BankAccountModelQuerySet, BankAccountModel
-from django_ledger.models.chart_of_accounts import ChartOfAccountModel, ChartOfAccountModelQuerySet
+from django_ledger.io import IODigestContextManager, validate_roles
+from django_ledger.io import roles as roles_module
+from django_ledger.io.io_core import IOMixIn, get_localdate, get_localtime
+
+from django_ledger.models.accounts import (
+    CREDIT,
+    DEBIT,
+    AccountModel,
+    AccountModelQuerySet,
+)
+from django_ledger.models.bank_account import BankAccountModel, BankAccountModelQuerySet
+from django_ledger.models.chart_of_accounts import (
+    ChartOfAccountModel,
+    ChartOfAccountModelQuerySet,
+)
 from django_ledger.models.coa_default import CHART_OF_ACCOUNTS_ROOT_MAP
-from django_ledger.models.customer import CustomerModelQueryset, CustomerModel
-from django_ledger.models.items import (ItemModelQuerySet, ItemTransactionModelQuerySet,
-                                        UnitOfMeasureModel, UnitOfMeasureModelQuerySet, ItemModel)
+from django_ledger.models.customer import CustomerModel, CustomerModelQueryset
+from django_ledger.models.items import (
+    ItemModel,
+    ItemModelQuerySet,
+    ItemTransactionModelQuerySet,
+    UnitOfMeasureModel,
+    UnitOfMeasureModelQuerySet,
+)
 from django_ledger.models.ledger import LedgerModel
-from django_ledger.models.mixins import CreateUpdateMixIn, SlugNameMixIn, ContactInfoMixIn, LoggingMixIn
+from django_ledger.models.mixins import (
+    ContactInfoMixIn,
+    CreateUpdateMixIn,
+    LoggingMixIn,
+    SlugNameMixIn,
+)
 from django_ledger.models.unit import EntityUnitModel
 from django_ledger.models.utils import lazy_loader
-from django_ledger.models.vendor import VendorModelQuerySet, VendorModel
+from django_ledger.models.vendor import VendorModel, VendorModelQuerySet
 from django_ledger.settings import DJANGO_LEDGER_DEFAULT_CLOSING_ENTRY_CACHE_TIMEOUT
 
 UserModel = get_user_model()
@@ -71,7 +92,7 @@ class EntityModelQuerySet(MP_NodeQuerySet):
     Inherits from the Materialized Path Node QuerySet Class from Django Treebeard.
     """
 
-    def hidden(self):
+    def hidden(self) -> 'EntityModelQuerySet':
         """
         A QuerySet of all hidden EntityModel.
 
@@ -82,7 +103,7 @@ class EntityModelQuerySet(MP_NodeQuerySet):
         """
         return self.filter(hidden=True)
 
-    def visible(self):
+    def visible(self) -> 'EntityModelQuerySet':
         """
         A Queryset of all visible EntityModel.
 
@@ -108,15 +129,15 @@ class EntityModelManager(MP_NodeManager):
 
     """
 
-    def get_queryset(self):
+    def get_queryset(self) -> EntityModelQuerySet:
         """Sets the custom queryset as the default."""
-        qs = EntityModelQuerySet(
-            self.model,
-            using=self._db).order_by('path')
-        return qs.order_by('path').select_related(
-            'admin',
-            'default_coa').annotate(
-            _default_coa_slug=F('default_coa__slug'),
+        qs = EntityModelQuerySet(self.model, using=self._db).order_by('path')
+        return (
+            qs.order_by('path')
+            .select_related('admin', 'default_coa')
+            .annotate(
+                _default_coa_slug=F('default_coa__slug'),
+            )
         )
 
     def for_user(self, user_model, authorized_superuser: bool = False):
@@ -141,10 +162,7 @@ class EntityModelManager(MP_NodeManager):
         qs = self.get_queryset()
         if user_model.is_superuser and authorized_superuser:
             return qs
-        return qs.filter(
-            Q(admin=user_model) |
-            Q(managers__in=[user_model])
-        )
+        return qs.filter(Q(admin=user_model) | Q(managers__in=[user_model]))
 
 
 class EntityModelFiscalPeriodMixIn:
@@ -153,6 +171,7 @@ class EntityModelFiscalPeriodMixIn:
     EntityModel. At the moment of creation, an EntityModel must be assigned a calendar month which is going to
     determine the start of the Fiscal Year.
     """
+
     VALID_QUARTERS = list(range(1, 5))
     VALID_MONTHS = list(range(1, 13))
 
@@ -179,7 +198,9 @@ class EntityModelFiscalPeriodMixIn:
             # current object is not an entity, get current entity and fetch its fy_start_month value
 
             # if current object is a detail view with an object...
-            obj = getattr(self, 'object')
+            obj = getattr(self, 'object', None) or getattr(
+                self, 'AUTHORIZED_ENTITY_MODEL'
+            )
             if isinstance(obj, EntityModel):
                 entity = obj
             elif isinstance(obj, LedgerModel):
@@ -251,7 +272,9 @@ class EntityModelFiscalPeriodMixIn:
         """
         if fy_start_month:
             self.validate_month(fy_start_month)
-        fy_start_month = self.get_fy_start_month() if not fy_start_month else fy_start_month
+        fy_start_month = (
+            self.get_fy_start_month() if not fy_start_month else fy_start_month
+        )
         return date(year, fy_start_month, 1)
 
     def get_fy_end(self, year: int, fy_start_month: int = None) -> date:
@@ -273,12 +296,16 @@ class EntityModelFiscalPeriodMixIn:
         """
         if fy_start_month:
             self.validate_month(fy_start_month)
-        fy_start_month = self.get_fy_start_month() if not fy_start_month else fy_start_month
+        fy_start_month = (
+            self.get_fy_start_month() if not fy_start_month else fy_start_month
+        )
         ye = year if fy_start_month == 1 else year + 1
         me = 12 if fy_start_month == 1 else fy_start_month - 1
         return date(ye, me, monthrange(ye, me)[1])
 
-    def get_quarter_start(self, year: int, quarter: int, fy_start_month: int = None) -> date:
+    def get_quarter_start(
+        self, year: int, quarter: int, fy_start_month: int = None
+    ) -> date:
         """
         The fiscal year quarter starting date of the EntityModel, according to its settings.
 
@@ -300,7 +327,9 @@ class EntityModelFiscalPeriodMixIn:
         """
         if fy_start_month:
             self.validate_month(fy_start_month)
-        fy_start_month = self.get_fy_start_month() if not fy_start_month else fy_start_month
+        fy_start_month = (
+            self.get_fy_start_month() if not fy_start_month else fy_start_month
+        )
         self.validate_quarter(quarter)
         quarter_month_start = (quarter - 1) * 3 + fy_start_month
         year_start = year
@@ -309,7 +338,9 @@ class EntityModelFiscalPeriodMixIn:
             year_start = year + 1
         return date(year_start, quarter_month_start, 1)
 
-    def get_quarter_end(self, year: int, quarter: int, fy_start_month: int = None) -> date:
+    def get_quarter_end(
+        self, year: int, quarter: int, fy_start_month: int = None
+    ) -> date:
         """
         The fiscal year quarter ending date of the EntityModel, according to its settings.
 
@@ -331,16 +362,22 @@ class EntityModelFiscalPeriodMixIn:
         """
         if fy_start_month:
             self.validate_month(fy_start_month)
-        fy_start_month = self.get_fy_start_month() if not fy_start_month else fy_start_month
+        fy_start_month = (
+            self.get_fy_start_month() if not fy_start_month else fy_start_month
+        )
         self.validate_quarter(quarter)
         quarter_month_end = quarter * 3 + fy_start_month - 1
         year_end = year
         if quarter_month_end > 12:
             quarter_month_end -= 12
             year_end += 1
-        return date(year_end, quarter_month_end, monthrange(year_end, quarter_month_end)[1])
+        return date(
+            year_end, quarter_month_end, monthrange(year_end, quarter_month_end)[1]
+        )
 
-    def get_fiscal_year_dates(self, year: int, fy_start_month: int = None) -> Tuple[date, date]:
+    def get_fiscal_year_dates(
+        self, year: int, fy_start_month: int = None
+    ) -> Tuple[date, date]:
         """
         Convenience method to get in one shot both, fiscal year start and end dates.
 
@@ -365,7 +402,9 @@ class EntityModelFiscalPeriodMixIn:
         ed = self.get_fy_end(year, fy_start_month)
         return sd, ed
 
-    def get_fiscal_quarter_dates(self, year: int, quarter: int, fy_start_month: int = None) -> Tuple[date, date]:
+    def get_fiscal_quarter_dates(
+        self, year: int, quarter: int, fy_start_month: int = None
+    ) -> Tuple[date, date]:
         """
         Convenience method to get in one shot both, fiscal year quarter start and end dates.
 
@@ -394,7 +433,9 @@ class EntityModelFiscalPeriodMixIn:
         qe = self.get_quarter_end(year, quarter, fy_start_month)
         return qs, qe
 
-    def get_fy_for_date(self, dt: Union[date, datetime], as_str: bool = False) -> Union[str, int]:
+    def get_fy_for_date(
+        self, dt: Union[date, datetime], as_str: bool = False
+    ) -> Union[str, int]:
         """
         Given a known date, returns the EntityModel fiscal year associated with the given date.
 
@@ -428,32 +469,39 @@ class EntityModelClosingEntryMixIn:
     Closing Entries provide
     """
 
-    def validate_closing_entry_model(self, closing_entry_model, closing_date: Optional[date] = None):
+    def validate_closing_entry_model(
+        self, closing_entry_model, closing_date: Optional[date] = None
+    ):
         if isinstance(self, EntityModel):
             if self.uuid != closing_entry_model.entity_model_id:
                 raise EntityModelValidationError(
-                    message=_(f'The Closing Entry Model {closing_entry_model} does not belong to Entity {self.name}')
+                    message=_(
+                        f'The Closing Entry Model {closing_entry_model} does not belong to Entity {self.name}'
+                    )
                 )
         if closing_date and closing_entry_model.closing_date != closing_date:
             raise EntityModelValidationError(
-                message=_(f'The Closing Entry Model date {closing_entry_model.closing_date} '
-                          f'does not match explicitly provided closing_date {closing_date}')
+                message=_(
+                    f'The Closing Entry Model date {closing_entry_model.closing_date} '
+                    f'does not match explicitly provided closing_date {closing_date}'
+                )
             )
 
     # ---> Closing Entry IO Digest <---
-    def get_closing_entry_digest(self,
-                                 to_date: date,
-                                 from_date: Optional[date] = None,
-                                 user_model: Optional[UserModel] = None,
-                                 closing_entry_model=None,
-                                 **kwargs: Dict) -> Tuple:
+    def get_closing_entry_digest(
+        self,
+        to_date: date,
+        from_date: Optional[date] = None,
+        user_model: Optional[UserModel] = None,
+        closing_entry_model=None,
+        **kwargs: Dict,
+    ) -> Tuple:
         ClosingEntryModel = lazy_loader.get_closing_entry_model()
         ClosingEntryTransactionModel = lazy_loader.get_closing_entry_transaction_model()
 
         if not closing_entry_model:
             closing_entry_model = ClosingEntryModel(
-                entity_model=self,
-                closing_date=to_date
+                entity_model=self, closing_date=to_date
             )
             closing_entry_model.clean()
         else:
@@ -466,7 +514,7 @@ class EntityModelClosingEntryMixIn:
             by_unit=True,
             by_activity=True,
             signs=False,
-            **kwargs
+            **kwargs,
         )
         ce_data = io_digest.get_closing_entry_data()
 
@@ -477,8 +525,9 @@ class EntityModelClosingEntryMixIn:
                 unit_model_id=ce['unit_uuid'],
                 tx_type=ce['balance_type'],
                 activity=ce['activity'],
-                balance=ce['balance']
-            ) for ce in ce_data
+                balance=ce['balance'],
+            )
+            for ce in ce_data
         ]
 
         for ce in ce_txs_list:
@@ -486,25 +535,25 @@ class EntityModelClosingEntryMixIn:
 
         return closing_entry_model, ce_txs_list
 
-    def get_closing_entry_digest_for_date(self,
-                                          closing_date: date,
-                                          closing_entry_model=None,
-                                          **kwargs) -> Tuple:
+    def get_closing_entry_digest_for_date(
+        self, closing_date: date, closing_entry_model=None, **kwargs
+    ) -> Tuple:
         return self.get_closing_entry_digest(
-            to_date=closing_date,
-            closing_entry_model=closing_entry_model,
-            **kwargs
+            to_date=closing_date, closing_entry_model=closing_entry_model, **kwargs
         )
 
-    def get_closing_entry_digest_for_month(self,
-                                           year: int,
-                                           month: int,
-                                           **kwargs: Dict) -> Tuple:
+    def get_closing_entry_digest_for_month(
+        self, year: int, month: int, **kwargs: Dict
+    ) -> Tuple:
         _, day_end = monthrange(year, month)
         closing_date = date(year=year, month=month, day=day_end)
-        return self.get_closing_entry_digest_for_date(closing_date=closing_date, **kwargs)
+        return self.get_closing_entry_digest_for_date(
+            closing_date=closing_date, **kwargs
+        )
 
-    def get_closing_entry_digest_for_fiscal_year(self, fiscal_year: int, **kwargs: Dict) -> Tuple:
+    def get_closing_entry_digest_for_fiscal_year(
+        self, fiscal_year: int, **kwargs: Dict
+    ) -> Tuple:
         closing_date = getattr(self, 'get_fy_end')(year=fiscal_year)
         return self.get_closing_entry_digest_for_date(to_date=closing_date, **kwargs)
 
@@ -512,8 +561,8 @@ class EntityModelClosingEntryMixIn:
     def get_closing_entry_queryset_for_date(self, closing_date: date):
         ClosingEntryTransactionModel = lazy_loader.get_closing_entry_transaction_model()
         return ClosingEntryTransactionModel.objects.for_entity(
-            entity_slug=self,
-        ).filter(closing_entry_model__closing_date__exact=closing_date)
+            entity_model=self,
+        ).for_closing_date(closing_date)
 
     def get_closing_entry_queryset_for_month(self, year: int, month: int):
         _, end_day = monthrange(year, month)
@@ -525,27 +574,28 @@ class EntityModelClosingEntryMixIn:
         return self.get_closing_entry_queryset_for_date(closing_date=closing_date)
 
     # ----> Create Closing Entries <----
-    def create_closing_entry_for_date(self,
-                                      closing_date: date,
-                                      closing_entry_model=None,
-                                      closing_entry_exists=True):
-
+    def create_closing_entry_for_date(
+        self, closing_date: date, closing_entry_model=None, closing_entry_exists=True
+    ):
         if closing_entry_model:
-            self.validate_closing_entry_model(closing_entry_model, closing_date=closing_date)
+            self.validate_closing_entry_model(
+                closing_entry_model, closing_date=closing_date
+            )
 
         if closing_date > get_localdate():
             raise EntityModelValidationError(
-                message=_(f'Cannot create closing entry with a future date {closing_date}.')
+                message=_(
+                    f'Cannot create closing entry with a future date {closing_date}.'
+                )
             )
 
-        if closing_entry_model is None or closing_entry_exists:
+        if closing_entry_model is None:
             self.closingentrymodel_set.filter(closing_date__exact=closing_date).delete()
         else:
             closing_entry_model.closingentrytransactionmodel_set.all().delete()
 
         closing_entry_model, ce_txs_list = self.get_closing_entry_digest_for_date(
-            closing_date=closing_date,
-            closing_entry_model=closing_entry_model
+            closing_date=closing_date, closing_entry_model=closing_entry_model
         )
 
         if closing_entry_model is not None:
@@ -553,8 +603,7 @@ class EntityModelClosingEntryMixIn:
 
         ClosingEntryTransactionModel = lazy_loader.get_closing_entry_transaction_model()
         return closing_entry_model, ClosingEntryTransactionModel.objects.bulk_create(
-            objs=ce_txs_list,
-            batch_size=100
+            objs=ce_txs_list, batch_size=100
         )
 
     def create_closing_entry_for_month(self, year: int, month: int):
@@ -583,21 +632,26 @@ class EntityModelClosingEntryMixIn:
         return f'closing_entry_{end_dt_str}_{self.uuid}'
 
     # ----> Closing Entry Caching Month < -----
-    def get_closing_entry_cache_for_date(self,
-                                         closing_date: date,
-                                         cache_name: str = 'default',
-                                         force_cache_update: bool = False,
-                                         cache_timeout: Optional[int] = None,
-                                         **kwargs):
-
+    def get_closing_entry_cache_for_date(
+        self,
+        closing_date: date,
+        cache_name: str = 'default',
+        force_cache_update: bool = False,
+        cache_timeout: Optional[int] = None,
+        **kwargs,
+    ):
         if not force_cache_update:
             cache_system = caches[cache_name]
-            ce_cache_key = self.get_closing_entry_cache_key_for_date(closing_date=closing_date)
+            ce_cache_key = self.get_closing_entry_cache_key_for_date(
+                closing_date=closing_date
+            )
             ce_ser = cache_system.get(ce_cache_key)
 
             # if closing entry is in cache...
             if ce_ser:
-                ce_qs_serde_gen = serializers.deserialize(format='json', stream_or_string=ce_ser)
+                ce_qs_serde_gen = serializers.deserialize(
+                    format='json', stream_or_string=ce_ser
+                )
                 return list(ce.object for ce in ce_qs_serde_gen)
             return
 
@@ -605,16 +659,18 @@ class EntityModelClosingEntryMixIn:
             closing_date=closing_date,
             cache_name=cache_name,
             cache_timeout=cache_timeout,
-            **kwargs)
-
-    def get_closing_entry_cache_for_month(self,
-                                          year: int,
-                                          month: int,
-                                          cache_name: str = 'default',
-                                          force_cache_update: bool = False,
-                                          cache_timeout: Optional[int] = None,
-                                          **kwargs):
+            **kwargs,
+        )
 
+    def get_closing_entry_cache_for_month(
+        self,
+        year: int,
+        month: int,
+        cache_name: str = 'default',
+        force_cache_update: bool = False,
+        cache_timeout: Optional[int] = None,
+        **kwargs,
+    ):
         _, day = monthrange(year, month)
         closing_date = date(year, month, day)
         return self.get_closing_entry_cache_for_date(
@@ -622,33 +678,39 @@ class EntityModelClosingEntryMixIn:
             cache_name=cache_name,
             force_cache_update=force_cache_update,
             cache_timeout=cache_timeout,
-            **kwargs
+            **kwargs,
         )
 
-    def get_closing_entry_cache_for_fiscal_year(self,
-                                                fiscal_year: int,
-                                                cache_name: str = 'default',
-                                                force_cache_update: bool = False,
-                                                cache_timeout: Optional[int] = None,
-                                                **kwargs):
+    def get_closing_entry_cache_for_fiscal_year(
+        self,
+        fiscal_year: int,
+        cache_name: str = 'default',
+        force_cache_update: bool = False,
+        cache_timeout: Optional[int] = None,
+        **kwargs,
+    ):
         closing_date: date = getattr(self, 'get_fy_end')(year=fiscal_year)
         return self.get_closing_entry_cache_for_date(
             closing_date=closing_date,
             cache_name=cache_name,
             force_cache_update=force_cache_update,
             cache_timeout=cache_timeout,
-            **kwargs
+            **kwargs,
         )
 
     # ---> SAVE CLOSING ENTRY <---
-    def save_closing_entry_cache_for_date(self,
-                                          closing_date: date,
-                                          cache_name: str = 'default',
-                                          cache_timeout: Optional[int] = None,
-                                          **kwargs):
+    def save_closing_entry_cache_for_date(
+        self,
+        closing_date: date,
+        cache_name: str = 'default',
+        cache_timeout: Optional[int] = None,
+        **kwargs,
+    ):
         cache_system = caches[cache_name]
         ce_qs = self.get_closing_entry_queryset_for_date(closing_date=closing_date)
-        ce_cache_key = self.get_closing_entry_cache_key_for_date(closing_date=closing_date)
+        ce_cache_key = self.get_closing_entry_cache_key_for_date(
+            closing_date=closing_date
+        )
         ce_ser = serializers.serialize(format='json', queryset=ce_qs)
 
         if not cache_timeout:
@@ -657,43 +719,49 @@ class EntityModelClosingEntryMixIn:
         cache_system.set(ce_cache_key, ce_ser, cache_timeout, **kwargs)
         return list(ce_qs)
 
-    def save_closing_entry_cache_for_month(self,
-                                           year: int,
-                                           month: int,
-                                           cache_name: str = 'default',
-                                           cache_timeout: Optional[int] = None,
-                                           **kwargs):
+    def save_closing_entry_cache_for_month(
+        self,
+        year: int,
+        month: int,
+        cache_name: str = 'default',
+        cache_timeout: Optional[int] = None,
+        **kwargs,
+    ):
         _, day = monthrange(year, month)
         closing_date = date(year, month, day)
         return self.save_closing_entry_cache_for_date(
             closing_date=closing_date,
             cache_name=cache_name,
             cache_timeout=cache_timeout,
-            **kwargs
+            **kwargs,
         )
 
-    def save_closing_entry_cache_for_fiscal_year(self,
-                                                 fiscal_year: int,
-                                                 cache_name: str = 'default',
-                                                 cache_timeout: Optional[int] = None,
-                                                 **kwargs):
+    def save_closing_entry_cache_for_fiscal_year(
+        self,
+        fiscal_year: int,
+        cache_name: str = 'default',
+        cache_timeout: Optional[int] = None,
+        **kwargs,
+    ):
         closing_date: date = getattr(self, 'get_fy_end')(year=fiscal_year)
         return self.save_closing_entry_cache_for_date(
             closing_date=closing_date,
             cache_name=cache_name,
             cache_timeout=cache_timeout,
-            **kwargs
+            **kwargs,
         )
 
 
-class EntityModelAbstract(MP_Node,
-                          SlugNameMixIn,
-                          CreateUpdateMixIn,
-                          ContactInfoMixIn,
-                          IOMixIn,
-                          LoggingMixIn,
-                          EntityModelFiscalPeriodMixIn,
-                          EntityModelClosingEntryMixIn):
+class EntityModelAbstract(
+    MP_Node,
+    SlugNameMixIn,
+    CreateUpdateMixIn,
+    ContactInfoMixIn,
+    IOMixIn,
+    LoggingMixIn,
+    EntityModelFiscalPeriodMixIn,
+    EntityModelClosingEntryMixIn,
+):
     """
     The base implementation of the EntityModel. The EntityModel represents the Company, Corporation, Legal Entity,
     Enterprise or Person that engage and operate as a business. The base model inherit from the Materialized Path Node
@@ -765,37 +833,46 @@ class EntityModelAbstract(MP_Node,
 
     uuid = models.UUIDField(default=uuid4, editable=False, primary_key=True)
     name = models.CharField(max_length=150, verbose_name=_('Entity Name'))
-    default_coa = models.OneToOneField('django_ledger.ChartOfAccountModel',
-                                       verbose_name=_('Default Chart of Accounts'),
-                                       blank=True,
-                                       null=True,
-                                       on_delete=models.PROTECT)
-    admin = models.ForeignKey(UserModel,
-                              on_delete=models.CASCADE,
-                              related_name='admin_of',
-                              verbose_name=_('Admin'))
-    managers = models.ManyToManyField(UserModel,
-                                      through='EntityManagementModel',
-                                      related_name='managed_by',
-                                      verbose_name=_('Managers'))
+    default_coa = models.OneToOneField(
+        'django_ledger.ChartOfAccountModel',
+        verbose_name=_('Default Chart of Accounts'),
+        blank=True,
+        null=True,
+        on_delete=models.PROTECT,
+    )
+    admin = models.ForeignKey(
+        UserModel,
+        on_delete=models.CASCADE,
+        related_name='admin_of',
+        verbose_name=_('Admin'),
+    )
+    managers = models.ManyToManyField(
+        UserModel,
+        through='EntityManagementModel',
+        related_name='managed_by',
+        verbose_name=_('Managers'),
+    )
 
     hidden = models.BooleanField(default=False)
-    accrual_method = models.BooleanField(default=False, verbose_name=_('Use Accrual Method'))
-    fy_start_month = models.IntegerField(choices=FY_MONTHS, default=1, verbose_name=_('Fiscal Year Start'))
-    last_closing_date = models.DateField(null=True, blank=True, verbose_name=_('Last Closing Entry Date'))
+    accrual_method = models.BooleanField(
+        default=False, verbose_name=_('Use Accrual Method')
+    )
+    fy_start_month = models.IntegerField(
+        choices=FY_MONTHS, default=1, verbose_name=_('Fiscal Year Start')
+    )
+    last_closing_date = models.DateField(
+        null=True, blank=True, verbose_name=_('Last Closing Entry Date')
+    )
     picture = models.ImageField(blank=True, null=True)
     meta = models.JSONField(default=dict, null=True, blank=True)
     objects = EntityModelManager.from_queryset(queryset_class=EntityModelQuerySet)()
 
-
     class Meta:
         abstract = True
         ordering = ['-created']
         verbose_name = _('Entity')
         verbose_name_plural = _('Entities')
-        indexes = [
-            models.Index(fields=['admin'])
-        ]
+        indexes = [models.Index(fields=['admin'])]
 
     def __str__(self):
         return f'EntityModel {self.slug}: {self.name}'
@@ -817,12 +894,14 @@ class EntityModelAbstract(MP_Node,
 
     # ## ENTITY CREATION ###
     @classmethod
-    def create_entity(cls,
-                      name: str,
-                      use_accrual_method: bool,
-                      admin: UserModel,
-                      fy_start_month: int,
-                      parent_entity=None):
+    def create_entity(
+        cls,
+        name: str,
+        use_accrual_method: bool,
+        admin: UserModel,
+        fy_start_month: int,
+        parent_entity=None,
+    ):
         """
         Convenience Method to Create a new Entity Model. This is the preferred method to create new Entities in order
         to properly handle potential parent/child relationships between EntityModels.
@@ -849,7 +928,7 @@ class EntityModelAbstract(MP_Node,
             name=name,
             accrual_method=use_accrual_method,
             fy_start_month=fy_start_month,
-            admin=admin
+            admin=admin,
         )
         entity_model.clean()
         entity_model = cls.add_root(instance=entity_model)
@@ -857,22 +936,28 @@ class EntityModelAbstract(MP_Node,
             if isinstance(parent_entity, str):
                 # get by slug...
                 try:
-                    parent_entity_model = EntityModel.objects.get(slug__exact=parent_entity, admin=admin)
+                    parent_entity_model = EntityModel.objects.get(
+                        slug__exact=parent_entity, admin=admin
+                    )
                 except ObjectDoesNotExist:
                     raise EntityModelValidationError(
                         message=_(
                             f'Invalid Parent Entity. '
-                            f'Entity with slug {parent_entity} is not administered by {admin.username}')
+                            f'Entity with slug {parent_entity} is not administered by {admin.username}'
+                        )
                     )
             elif isinstance(parent_entity, UUID):
                 # get by uuid...
                 try:
-                    parent_entity_model = EntityModel.objects.get(uuid__exact=parent_entity, admin=admin)
+                    parent_entity_model = EntityModel.objects.get(
+                        uuid__exact=parent_entity, admin=admin
+                    )
                 except ObjectDoesNotExist:
                     raise EntityModelValidationError(
                         message=_(
                             f'Invalid Parent Entity. '
-                            f'Entity with UUID {parent_entity} is not administered by {admin.username}')
+                            f'Entity with UUID {parent_entity} is not administered by {admin.username}'
+                        )
                     )
             elif isinstance(parent_entity, cls):
                 # EntityModel instance provided...
@@ -880,7 +965,8 @@ class EntityModelAbstract(MP_Node,
                     raise EntityModelValidationError(
                         message=_(
                             f'Invalid Parent Entity. '
-                            f'Entity {parent_entity} is not administered by {admin.username}')
+                            f'Entity {parent_entity} is not administered by {admin.username}'
+                        )
                     )
                 parent_entity_model = parent_entity
             else:
@@ -907,15 +993,18 @@ class EntityModelAbstract(MP_Node,
         return user_model.id == self.admin_id
 
     # #### LEDGER MANAGEMENT....
-    def create_ledger(self, name: str, ledger_xid: Optional[str] = None, posted: bool = False, commit: bool = True):
+    def create_ledger(
+        self,
+        name: str,
+        ledger_xid: Optional[str] = None,
+        posted: bool = False,
+        commit: bool = True,
+    ):
         if commit:
-            return self.ledgermodel_set.create(name=name, ledger_xid=ledger_xid, posted=posted)
-        return LedgerModel(
-            entity=self,
-            posted=posted,
-            name=name,
-            ledger_xid=ledger_xid
-        )
+            return self.ledgermodel_set.create(
+                name=name, ledger_xid=ledger_xid, posted=posted
+            )
+        return LedgerModel(entity=self, posted=posted, name=name, ledger_xid=ledger_xid)
 
     # #### SLUG GENERATION ###
     @staticmethod
@@ -937,10 +1026,12 @@ class EntityModelAbstract(MP_Node,
         entity_slug = f'{slug}-{suffix}'
         return entity_slug
 
-    def generate_slug(self,
-                      commit: bool = False,
-                      raise_exception: bool = True,
-                      force_update: bool = False) -> str:
+    def generate_slug(
+        self,
+        commit: bool = False,
+        raise_exception: bool = True,
+        force_update: bool = False,
+    ) -> str:
         """
         Convenience method to create the EntityModel slug.
 
@@ -958,16 +1049,15 @@ class EntityModelAbstract(MP_Node,
         if not force_update and self.slug:
             if raise_exception:
                 raise ValidationError(
-                    message=_(f'Cannot replace existing slug {self.slug}. Use force_update=True if needed.')
+                    message=_(
+                        f'Cannot replace existing slug {self.slug}. Use force_update=True if needed.'
+                    )
                 )
 
         self.slug = self.generate_slug_from_name(self.name)
 
         if commit:
-            self.save(update_fields=[
-                'slug',
-                'updated'
-            ])
+            self.save(update_fields=['slug', 'updated'])
         return self.slug
 
     # #### CHART OF ACCOUNTS ####
@@ -982,7 +1072,9 @@ class EntityModelAbstract(MP_Node,
         """
         return self.default_coa_id is not None
 
-    def get_default_coa(self, raise_exception: bool = True) -> Optional[ChartOfAccountModel]:
+    def get_default_coa(
+        self, raise_exception: bool = True
+    ) -> Optional[ChartOfAccountModel]:
         """
         Fetches the EntityModel default Chart of Account.
 
@@ -999,11 +1091,14 @@ class EntityModelAbstract(MP_Node,
 
         if not self.default_coa_id:
             if raise_exception:
-                raise EntityModelValidationError(f'EntityModel {self.slug} does not have a default CoA')
+                raise EntityModelValidationError(
+                    f'EntityModel {self.slug} does not have a default CoA'
+                )
         return self.default_coa
 
-    def set_default_coa(self, coa_model: Optional[Union[ChartOfAccountModel, str]], commit: bool = False):
-
+    def set_default_coa(
+        self, coa_model: Optional[Union[ChartOfAccountModel, str]], commit: bool = False
+    ):
         # if str, will look up CoA Model by slug...
         if isinstance(coa_model, str):
             coa_model = self.chartofaccountmodel_set.get(slug=coa_model)
@@ -1012,15 +1107,14 @@ class EntityModelAbstract(MP_Node,
 
         self.default_coa = coa_model
         if commit:
-            self.save(update_fields=[
-                'default_coa',
-                'updated'
-            ])
+            self.save(update_fields=['default_coa', 'updated'])
 
-    def create_chart_of_accounts(self,
-                                 assign_as_default: bool = False,
-                                 coa_name: Optional[str] = None,
-                                 commit: bool = False) -> ChartOfAccountModel:
+    def create_chart_of_accounts(
+        self,
+        assign_as_default: bool = False,
+        coa_name: Optional[str] = None,
+        commit: bool = False,
+    ) -> ChartOfAccountModel:
         """
         Creates a Chart of Accounts for the Entity Model and optionally assign it as the default Chart of Accounts.
         EntityModel must have a default Chart of Accounts before being able to transact.
@@ -1045,10 +1139,7 @@ class EntityModelAbstract(MP_Node,
         if not coa_name:
             coa_name = 'Default CoA'
 
-        chart_of_accounts = ChartOfAccountModel(
-            name=coa_name,
-            entity=self
-        )
+        chart_of_accounts = ChartOfAccountModel(name=coa_name, entity=self)
 
         chart_of_accounts.clean()
         chart_of_accounts.save()
@@ -1057,18 +1148,17 @@ class EntityModelAbstract(MP_Node,
         if assign_as_default:
             self.default_coa = chart_of_accounts
             if commit:
-                self.save(update_fields=[
-                    'default_coa',
-                    'updated'
-                ])
+                self.save(update_fields=['default_coa', 'updated'])
         return chart_of_accounts
 
-    def populate_default_coa(self,
-                             activate_accounts: bool = False,
-                             force: bool = False,
-                             ignore_if_default_coa: bool = True,
-                             coa_model: Optional[ChartOfAccountModel] = None,
-                             commit: bool = True):
+    def populate_default_coa(
+        self,
+        activate_accounts: bool = False,
+        force: bool = False,
+        ignore_if_default_coa: bool = True,
+        coa_model: Optional[ChartOfAccountModel] = None,
+        commit: bool = True,
+    ):
         """
         Populates the EntityModel default CoA with the default Chart of Account list provided by Django Ledger or user
         defined. See DJANGO_LEDGER_DEFAULT_COA setting.
@@ -1113,13 +1203,18 @@ class EntityModelAbstract(MP_Node,
                         balance_type=a['balance_type'],
                         active=activate_accounts,
                         coa_model=coa_model,
-                    ) for a in v] for k, v in CHART_OF_ACCOUNTS_ROOT_MAP.items()
+                    )
+                    for a in v
+                ]
+                for k, v in CHART_OF_ACCOUNTS_ROOT_MAP.items()
             }
 
             for root_acc, acc_model_list in root_maps.items():
                 roles_set = set(account_model.role for account_model in acc_model_list)
                 for i, account_model in enumerate(acc_model_list):
-                    account_model.role_default = True if account_model.role in roles_set else False
+                    account_model.role_default = (
+                        True if account_model.role in roles_set else False
+                    )
 
                     try:
                         roles_set.remove(account_model.role)
@@ -1127,7 +1222,9 @@ class EntityModelAbstract(MP_Node,
                         pass
 
                     account_model.clean()
-                    coa_model.insert_account(account_model, root_account_qs=root_account_qs)
+                    coa_model.insert_account(
+                        account_model, root_account_qs=root_account_qs
+                    )
 
         else:
             if not ignore_if_default_coa:
@@ -1156,9 +1253,9 @@ class EntityModelAbstract(MP_Node,
         return coa_model_qs
 
     # Model Validators....
-    def validate_chart_of_accounts_for_entity(self,
-                                              coa_model: ChartOfAccountModel,
-                                              raise_exception: bool = True) -> bool:
+    def validate_chart_of_accounts_for_entity(
+        self, coa_model: ChartOfAccountModel, raise_exception: bool = True
+    ) -> bool:
         """
         Validates the CoA Model against the EntityModel instance.
 
@@ -1178,13 +1275,16 @@ class EntityModelAbstract(MP_Node,
             return True
         if raise_exception:
             raise EntityModelValidationError(
-                f'Invalid ChartOfAccounts model {coa_model.slug} for EntityModel {self.slug}')
+                f'Invalid ChartOfAccounts model {coa_model.slug} for EntityModel {self.slug}'
+            )
         return False
 
-    def validate_account_model_for_coa(self,
-                                       account_model: AccountModel,
-                                       coa_model: ChartOfAccountModel,
-                                       raise_exception: bool = True) -> bool:
+    def validate_account_model_for_coa(
+        self,
+        account_model: AccountModel,
+        coa_model: ChartOfAccountModel,
+        raise_exception: bool = True,
+    ) -> bool:
         """
         Validates that the AccountModel provided belongs to the CoA Model provided.
 
@@ -1202,7 +1302,9 @@ class EntityModelAbstract(MP_Node,
         bool
             True if valid, else False.
         """
-        valid = self.validate_chart_of_accounts_for_entity(coa_model, raise_exception=raise_exception)
+        valid = self.validate_chart_of_accounts_for_entity(
+            coa_model, raise_exception=raise_exception
+        )
         if not valid:
             return valid
         if valid and account_model.coa_model_id == coa_model.uuid:
@@ -1216,17 +1318,23 @@ class EntityModelAbstract(MP_Node,
     @staticmethod
     def validate_account_model_for_role(account_model: AccountModel, role: str):
         if account_model.role != role:
-            raise EntityModelValidationError(f'Invalid account role: {account_model.role}, expected {role}')
+            raise EntityModelValidationError(
+                f'Invalid account role: {account_model.role}, expected {role}'
+            )
 
-    def validate_ledger_model_for_entity(self, ledger_model: Union[LedgerModel, UUID, str]):
+    def validate_ledger_model_for_entity(
+        self, ledger_model: Union[LedgerModel, UUID, str]
+    ):
         if ledger_model.entity_id != self.uuid:
-            raise EntityModelValidationError(f'Invalid LedgerModel {ledger_model.uuid} for entity {self.slug}')
-
-    def get_all_coa_accounts(self,
-                             order_by: Optional[Tuple[str]] = ('code',),
-                             active: bool = True) -> Tuple[
-        ChartOfAccountModelQuerySet, Dict[ChartOfAccountModel, AccountModelQuerySet]]:
+            raise EntityModelValidationError(
+                f'Invalid LedgerModel {ledger_model.uuid} for entity {self.slug}'
+            )
 
+    def get_all_coa_accounts(
+        self, order_by: Optional[Tuple[str]] = ('code',), active: bool = True
+    ) -> Tuple[
+        ChartOfAccountModelQuerySet, Dict[ChartOfAccountModel, AccountModelQuerySet]
+    ]:
         """
         Fetches all the AccountModels associated with the EntityModel grouped by ChartOfAccountModel.
 
@@ -1243,17 +1351,23 @@ class EntityModelAbstract(MP_Node,
             The ChartOfAccountModelQuerySet and a grouping of AccountModels by ChartOfAccountModel as keys.
         """
 
-        account_model_qs = ChartOfAccountModel.objects.filter(
-            entity_id=self.uuid
-        ).select_related('entity').prefetch_related('accountmodel_set')
+        account_model_qs = (
+            ChartOfAccountModel.objects.filter(entity_id=self.uuid)
+            .select_related('entity')
+            .prefetch_related('accountmodel_set')
+        )
 
         return account_model_qs, {
-            coa_model: coa_model.accountmodel_set.filter(active=active).order_by(*order_by) for coa_model in
-            account_model_qs
+            coa_model: coa_model.accountmodel_set.filter(active=active).order_by(
+                *order_by
+            )
+            for coa_model in account_model_qs
         }
 
     # ##### ACCOUNT MANAGEMENT ######
-    def get_all_accounts(self, active: bool = True, order_by: Optional[Tuple[str]] = ('code',)) -> AccountModelQuerySet:
+    def get_all_accounts(
+        self, active: bool = True, order_by: Optional[Tuple[str]] = ('code',)
+    ) -> AccountModelQuerySet:
         """
         Fetches all AccountModelQuerySet associated with the EntityModel.
 
@@ -1279,13 +1393,14 @@ class EntityModelAbstract(MP_Node,
             account_model_qs = account_model_qs.order_by(*order_by)
         return account_model_qs
 
-    def get_coa_accounts(self,
-                         coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                         active: bool = True,
-                         locked: bool = False,
-                         order_by: Optional[Tuple] = ('code',),
-                         return_coa_model: bool = False,
-                         ) -> Union[AccountModelQuerySet, Tuple[ChartOfAccountModel, AccountModelQuerySet]]:
+    def get_coa_accounts(
+        self,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        active: bool = True,
+        locked: bool = False,
+        order_by: Optional[Tuple] = ('code',),
+        return_coa_model: bool = False,
+    ) -> Union[AccountModelQuerySet, Tuple[ChartOfAccountModel, AccountModelQuerySet]]:
         """
         Fetches the AccountModelQuerySet for a specific ChartOfAccountModel.
 
@@ -1309,9 +1424,13 @@ class EntityModelAbstract(MP_Node,
         if not coa_model:
             coa_model = self.default_coa
         elif isinstance(coa_model, UUID):
-            coa_model = self.chartofaccountmodel_set.select_related('entity').get(uuid__exact=coa_model)
+            coa_model = self.chartofaccountmodel_set.select_related('entity').get(
+                uuid__exact=coa_model
+            )
         elif isinstance(coa_model, str):
-            coa_model = self.chartofaccountmodel_set.select_related('entity').get(slug__exact=coa_model)
+            coa_model = self.chartofaccountmodel_set.select_related('entity').get(
+                slug__exact=coa_model
+            )
         elif isinstance(coa_model, ChartOfAccountModel):
             self.validate_chart_of_accounts_for_entity(coa_model=coa_model)
         else:
@@ -1319,7 +1438,9 @@ class EntityModelAbstract(MP_Node,
                 f'CoA Model {coa_model} must be an instance of ChartOfAccountModel, UUID, str or None.'
             )
 
-        account_model_qs = coa_model.accountmodel_set.select_related('coa_model', 'coa_model__entity').not_coa_root()
+        account_model_qs = coa_model.accountmodel_set.select_related(
+            'coa_model', 'coa_model__entity'
+        ).not_coa_root()
 
         if active:
             account_model_qs = account_model_qs.active()
@@ -1334,10 +1455,12 @@ class EntityModelAbstract(MP_Node,
             return coa_model, account_model_qs
         return account_model_qs
 
-    def get_default_coa_accounts(self,
-                                 active: bool = True,
-                                 order_by: Optional[Tuple[str]] = ('code',),
-                                 raise_exception: bool = True) -> Optional[AccountModelQuerySet]:
+    def get_default_coa_accounts(
+        self,
+        active: bool = True,
+        order_by: Optional[Tuple[str]] = ('code',),
+        raise_exception: bool = True,
+    ) -> Optional[AccountModelQuerySet]:
         """
         Fetches the default AccountModelQuerySet.
 
@@ -1362,10 +1485,11 @@ class EntityModelAbstract(MP_Node,
 
         return self.get_coa_accounts(active=active, order_by=order_by)
 
-    def get_accounts_with_codes(self,
-                                code_list: Union[str, List[str], Set[str]],
-                                coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None
-                                ) -> AccountModelQuerySet:
+    def get_accounts_with_codes(
+        self,
+        code_list: Union[str, List[str], Set[str]],
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+    ) -> AccountModelQuerySet:
         """
         Fetches the AccountModelQuerySet with provided code list.
 
@@ -1392,9 +1516,9 @@ class EntityModelAbstract(MP_Node,
             return account_model_qs.filter(code__exact=code_list)
         return account_model_qs.filter(code__in=code_list)
 
-    def get_default_account_for_role(self,
-                                     role: str,
-                                     coa_model: Optional[ChartOfAccountModel] = None) -> AccountModel:
+    def get_default_account_for_role(
+        self, role: str, coa_model: Optional[ChartOfAccountModel] = None
+    ) -> AccountModel:
         """
         Gets the given role default AccountModel from the provided CoA.
         CoA will be validated against the EntityModel instance.
@@ -1420,14 +1544,16 @@ class EntityModelAbstract(MP_Node,
         account_model_qs = coa_model.accountmodel_set.all().is_role_default()
         return account_model_qs.get(role__exact=role)
 
-    def create_account(self,
-                       code: str,
-                       role: str,
-                       name: str,
-                       balance_type: str,
-                       active: bool = False,
-                       coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                       raise_exception: bool = True) -> AccountModel:
+    def create_account(
+        self,
+        code: str,
+        role: str,
+        name: str,
+        balance_type: str,
+        active: bool = False,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        raise_exception: bool = True,
+    ) -> AccountModel:
         """
         Creates a new AccountModel for the EntityModel.
 
@@ -1461,24 +1587,21 @@ class EntityModelAbstract(MP_Node,
                 coa_model = self.chartofaccountsmodel_set.get(slug__exact=coa_model)
             elif isinstance(coa_model, ChartOfAccountModel):
                 self.validate_chart_of_accounts_for_entity(
-                    coa_model=coa_model,
-                    raise_exception=raise_exception
+                    coa_model=coa_model, raise_exception=raise_exception
                 )
         else:
             coa_model = self.default_coa
 
         return coa_model.create_account(
-            code=code,
-            role=role,
-            name=name,
-            balance_type=balance_type,
-            active=active
+            code=code, role=role, name=name, balance_type=balance_type, active=active
         )
 
-    def create_account_by_kwargs(self,
-                                 account_model_kwargs: Dict,
-                                 coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                                 raise_exception: bool = True) -> Tuple[ChartOfAccountModel, AccountModel]:
+    def create_account_by_kwargs(
+        self,
+        account_model_kwargs: Dict,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        raise_exception: bool = True,
+    ) -> Tuple[ChartOfAccountModel, AccountModel]:
         """
         Creates a new AccountModel for the EntityModel by passing AccountModel KWARGS.
         This is a legacy method for creating a new AccountModel for the EntityModel.
@@ -1506,8 +1629,7 @@ class EntityModelAbstract(MP_Node,
                 coa_model = self.chartofaccountsmodel_set.get(slug__exact=coa_model)
             elif isinstance(coa_model, ChartOfAccountModel):
                 self.validate_chart_of_accounts_for_entity(
-                    coa_model=coa_model,
-                    raise_exception=raise_exception
+                    coa_model=coa_model, raise_exception=raise_exception
                 )
         else:
             coa_model = self.default_coa
@@ -1516,16 +1638,11 @@ class EntityModelAbstract(MP_Node,
         # account_model.clean()
         return coa_model, coa_model.create_account(**account_model_kwargs)
 
-    def get_account_balance(self,
-                            account_codes: List[str],
-                            to_date: Union[datetime, date, str],
-                            **kwargs):
-
+    def get_account_balance(
+        self, account_codes: List[str], to_date: Union[datetime, date, str], **kwargs
+    ):
         io_context = self.digest(
-            entity_model=self.slug,
-            accounts=account_codes,
-            to_date=to_date,
-            **kwargs
+            entity_model=self.slug, accounts=account_codes, to_date=to_date, **kwargs
         )
 
         return io_context
@@ -1538,7 +1655,6 @@ class EntityModelAbstract(MP_Node,
 
     # ### JOURNAL ENTRY MANAGEMENT ####
     def get_journal_entries(self, ledger_model: LedgerModel, posted: bool = True):
-
         if ledger_model:
             self.validate_ledger_model_for_entity(ledger_model)
             qs = ledger_model.journal_entries.all()
@@ -1547,7 +1663,7 @@ class EntityModelAbstract(MP_Node,
             return qs
 
         JournalEntryModel = lazy_loader.get_journal_entry_model()
-        qs = JournalEntryModel.objects.for_entity(entity_slug=self)
+        qs = JournalEntryModel.objects.for_entity(entity_model=self)
         if posted:
             return qs.posted()
         return qs
@@ -1580,7 +1696,9 @@ class EntityModelAbstract(MP_Node,
         vendor_model_qs = self.get_vendors()
         return vendor_model_qs.get(uuid__exact=vendor_uuid)
 
-    def create_vendor(self, vendor_model_kwargs: Dict, commit: bool = True) -> VendorModel:
+    def create_vendor(
+        self, vendor_model_kwargs: Dict, commit: bool = True
+    ) -> VendorModel:
         """
         Creates a new VendorModel associated with the EntityModel instance.
 
@@ -1631,9 +1749,13 @@ class EntityModelAbstract(MP_Node,
 
     def validate_customer(self, customer_model: CustomerModel):
         if customer_model.entity_model_id != self.uuid:
-            raise EntityModelValidationError(f'Invalid CustomerModel {self.uuid} for EntityModel {self.uuid}...')
+            raise EntityModelValidationError(
+                f'Invalid CustomerModel {self.uuid} for EntityModel {self.uuid}...'
+            )
 
-    def create_customer(self, customer_model_kwargs: Dict, commit: bool = True) -> CustomerModel:
+    def create_customer(
+        self, customer_model_kwargs: Dict, commit: bool = True
+    ) -> CustomerModel:
         """
         Creates a new CustomerModel associated with the EntityModel instance.
 
@@ -1654,6 +1776,11 @@ class EntityModelAbstract(MP_Node,
             customer_model.save()
         return customer_model
 
+    # ### RECEIPT MANAGEMENT ####
+    def get_receipts(self):
+        ReceiptModel = lazy_loader.get_receipt_model()
+        return ReceiptModel.objects.for_entity(entity_model=self)
+
     # ### BILL MANAGEMENT ####
     def get_bills(self):
         """
@@ -1668,18 +1795,20 @@ class EntityModelAbstract(MP_Node,
             ledger__entity__uuid__exact=self.uuid
         ).select_related('ledger', 'ledger__entity', 'vendor')
 
-    def create_bill(self,
-                    vendor_model: Union[VendorModel, UUID, str],
-                    terms: str,
-                    date_draft: Optional[Union[date, datetime]] = None,
-                    xref: Optional[str] = None,
-                    cash_account: Optional[AccountModel] = None,
-                    prepaid_account: Optional[AccountModel] = None,
-                    payable_account: Optional[AccountModel] = None,
-                    additional_info: Optional[Dict] = None,
-                    ledger_name: Optional[str] = None,
-                    coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                    commit: bool = True):
+    def create_bill(
+        self,
+        vendor_model: Union[VendorModel, UUID, str],
+        terms: str,
+        date_draft: Optional[Union[date, datetime]] = None,
+        xref: Optional[str] = None,
+        cash_account: Optional[AccountModel] = None,
+        prepaid_account: Optional[AccountModel] = None,
+        payable_account: Optional[AccountModel] = None,
+        additional_info: Optional[Dict] = None,
+        ledger_name: Optional[str] = None,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        commit: bool = True,
+    ):
         """
         Creates a new BillModel for the EntityModel instance.
         Bill will have DRAFT status.
@@ -1720,13 +1849,17 @@ class EntityModelAbstract(MP_Node,
 
         if isinstance(vendor_model, VendorModel):
             if not vendor_model.entity_model_id == self.uuid:
-                raise EntityModelValidationError(f'VendorModel {vendor_model.uuid} belongs to a different EntityModel.')
+                raise EntityModelValidationError(
+                    f'VendorModel {vendor_model.uuid} belongs to a different EntityModel.'
+                )
         elif isinstance(vendor_model, UUID):
             vendor_model = self.get_vendor_by_uuid(vendor_uuid=vendor_model)
         elif isinstance(vendor_model, str):
             vendor_model = self.get_vendor_by_number(vendor_number=vendor_model)
         else:
-            raise EntityModelValidationError('VendorModel must be an instance of VendorModel, UUID or str.')
+            raise EntityModelValidationError(
+                'VendorModel must be an instance of VendorModel, UUID or str.'
+            )
 
         account_model_qs = self.get_coa_accounts(coa_model=coa_model, active=True)
 
@@ -1734,8 +1867,9 @@ class EntityModelAbstract(MP_Node,
             roles=[
                 roles_module.ASSET_CA_CASH,
                 roles_module.ASSET_CA_PREPAID,
-                roles_module.LIABILITY_CL_ACC_PAYABLE
-            ]).is_role_default()
+                roles_module.LIABILITY_CL_ACC_PAYABLE,
+            ]
+        ).is_role_default()
 
         # evaluates the queryset...
         len(account_model_qs)
@@ -1745,20 +1879,26 @@ class EntityModelAbstract(MP_Node,
             vendor=vendor_model,
             terms=terms,
             additional_info=additional_info,
-            cash_account=account_model_qs.get(role=roles_module.ASSET_CA_CASH) if not cash_account else cash_account,
-            prepaid_account=account_model_qs.get(
-                role=roles_module.ASSET_CA_PREPAID
-            ) if not prepaid_account else prepaid_account,
+            cash_account=account_model_qs.get(role=roles_module.ASSET_CA_CASH)
+            if not cash_account
+            else cash_account,
+            prepaid_account=account_model_qs.get(role=roles_module.ASSET_CA_PREPAID)
+            if not prepaid_account
+            else prepaid_account,
             unearned_account=account_model_qs.get(
                 role=roles_module.LIABILITY_CL_ACC_PAYABLE
-            ) if not payable_account else payable_account
+            )
+            if not payable_account
+            else payable_account,
         )
 
-        _, bill_model = bill_model.configure(entity_slug=self,
-                                             ledger_name=ledger_name,
-                                             date_draft=date_draft,
-                                             commit=commit,
-                                             commit_ledger=commit)
+        _, bill_model = bill_model.configure(
+            entity_slug=self,
+            ledger_name=ledger_name,
+            date_draft=date_draft,
+            commit=commit,
+            commit_ledger=commit,
+        )
 
         return bill_model
 
@@ -1780,18 +1920,19 @@ class EntityModelAbstract(MP_Node,
             ledger__entity__uuid__exact=self.uuid
         ).select_related('ledger', 'ledger__entity', 'customer')
 
-    def create_invoice(self,
-                       customer_model: Union[VendorModel, UUID, str],
-                       terms: str,
-                       cash_account: Optional[AccountModel] = None,
-                       prepaid_account: Optional[AccountModel] = None,
-                       payable_account: Optional[AccountModel] = None,
-                       additional_info: Optional[Dict] = None,
-                       ledger_name: Optional[str] = None,
-                       coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                       date_draft: Optional[date] = None,
-                       commit: bool = True):
-
+    def create_invoice(
+        self,
+        customer_model: Union[VendorModel, UUID, str],
+        terms: str,
+        cash_account: Optional[AccountModel] = None,
+        prepaid_account: Optional[AccountModel] = None,
+        payable_account: Optional[AccountModel] = None,
+        additional_info: Optional[Dict] = None,
+        ledger_name: Optional[str] = None,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        date_draft: Optional[date] = None,
+        commit: bool = True,
+    ):
         """
         Creates a new InvoiceModel for the EntityModel instance.
         Invoice will have DRAFT status.
@@ -1831,21 +1972,25 @@ class EntityModelAbstract(MP_Node,
         if isinstance(customer_model, CustomerModel):
             if not customer_model.entity_model_id == self.uuid:
                 raise EntityModelValidationError(
-                    f'CustomerModel {customer_model.uuid} belongs to a different EntityModel.')
+                    f'CustomerModel {customer_model.uuid} belongs to a different EntityModel.'
+                )
         elif isinstance(customer_model, UUID):
             customer_model = self.get_customer_by_uuid(customer_uuid=customer_model)
         elif isinstance(customer_model, str):
             customer_model = self.get_customer_by_number(customer_number=customer_model)
         else:
-            raise EntityModelValidationError('CustomerModel must be an instance of CustomerModel, UUID or str.')
+            raise EntityModelValidationError(
+                'CustomerModel must be an instance of CustomerModel, UUID or str.'
+            )
 
         account_model_qs = self.get_coa_accounts(coa_model=coa_model, active=True)
         account_model_qs = account_model_qs.with_roles(
             roles=[
                 roles_module.ASSET_CA_CASH,
                 roles_module.ASSET_CA_RECEIVABLES,
-                roles_module.LIABILITY_CL_DEFERRED_REVENUE
-            ]).is_role_default()
+                roles_module.LIABILITY_CL_DEFERRED_REVENUE,
+            ]
+        ).is_role_default()
 
         # evaluates the queryset...
         len(account_model_qs)
@@ -1854,20 +1999,26 @@ class EntityModelAbstract(MP_Node,
             customer=customer_model,
             additional_info=additional_info,
             terms=terms,
-            cash_account=account_model_qs.get(role=roles_module.ASSET_CA_CASH) if not cash_account else cash_account,
-            prepaid_account=account_model_qs.get(
-                role=roles_module.ASSET_CA_RECEIVABLES
-            ) if not prepaid_account else prepaid_account,
+            cash_account=account_model_qs.get(role=roles_module.ASSET_CA_CASH)
+            if not cash_account
+            else cash_account,
+            prepaid_account=account_model_qs.get(role=roles_module.ASSET_CA_RECEIVABLES)
+            if not prepaid_account
+            else prepaid_account,
             unearned_account=account_model_qs.get(
                 role=roles_module.LIABILITY_CL_DEFERRED_REVENUE
-            ) if not payable_account else payable_account
+            )
+            if not payable_account
+            else payable_account,
         )
 
-        _, invoice_model = invoice_model.configure(entity_slug=self,
-                                                   ledger_name=ledger_name,
-                                                   commit=commit,
-                                                   date_draft=date_draft,
-                                                   commit_ledger=commit)
+        _, invoice_model = invoice_model.configure(
+            entity_slug=self,
+            ledger_name=ledger_name,
+            commit=commit,
+            date_draft=date_draft,
+            commit_ledger=commit,
+        )
 
         return invoice_model
 
@@ -1882,11 +2033,13 @@ class EntityModelAbstract(MP_Node,
         """
         return self.purchaseordermodel_set.all().select_related('entity')
 
-    def create_purchase_order(self,
-                              po_title: Optional[str] = None,
-                              estimate_model=None,
-                              date_draft: Optional[date] = None,
-                              commit: bool = True):
+    def create_purchase_order(
+        self,
+        po_title: Optional[str] = None,
+        estimate_model=None,
+        date_draft: Optional[date] = None,
+        commit: bool = True,
+    ):
         """
         Creates a new PurchaseOrderModel for the EntityModel instance.
         PO will have DRAFT status.
@@ -1914,7 +2067,7 @@ class EntityModelAbstract(MP_Node,
             draft_date=date_draft,
             estimate_model=estimate_model,
             commit=commit,
-            po_title=po_title
+            po_title=po_title,
         )
 
     # ### ESTIMATE/CONTRACT MANAGEMENT ####
@@ -1928,12 +2081,14 @@ class EntityModelAbstract(MP_Node,
         """
         return self.estimatemodel_set.all().select_related('entity')
 
-    def create_estimate(self,
-                        estimate_title: str,
-                        contract_terms: str,
-                        customer_model: Union[CustomerModel, UUID, str],
-                        date_draft: Optional[date] = None,
-                        commit: bool = True):
+    def create_estimate(
+        self,
+        estimate_title: str,
+        contract_terms: str,
+        customer_model: Union[CustomerModel, UUID, str],
+        date_draft: Optional[date] = None,
+        commit: bool = True,
+    ):
         """
         Creates a new EstimateModel for the EntityModel instance.
         Estimate will have DRAFT status.
@@ -1963,7 +2118,9 @@ class EntityModelAbstract(MP_Node,
         elif isinstance(customer_model, UUID):
             customer_model = self.get_customer_by_uuid(customer_uuid=customer_model)
         else:
-            raise EntityModelValidationError('CustomerModel must be an instance of CustomerModel, UUID or str.')
+            raise EntityModelValidationError(
+                'CustomerModel must be an instance of CustomerModel, UUID or str.'
+            )
 
         EstimateModel = lazy_loader.get_estimate_model()
         estimate_model = EstimateModel(terms=contract_terms)
@@ -1972,7 +2129,7 @@ class EntityModelAbstract(MP_Node,
             date_draft=date_draft,
             customer_model=customer_model,
             estimate_title=estimate_title,
-            commit=commit
+            commit=commit,
         )
 
     # ### BANK ACCOUNT MANAGEMENT ####
@@ -1994,15 +2151,16 @@ class EntityModelAbstract(MP_Node,
             bank_account_qs = bank_account_qs.active()
         return bank_account_qs
 
-    def create_bank_account(self,
-                            name: str,
-                            account_type: str,
-                            active=False,
-                            account_model: Optional[AccountModel] = None,
-                            coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                            bank_account_model_kwargs: Optional[Dict] = None,
-                            commit: bool = True):
-
+    def create_bank_account(
+        self,
+        name: str,
+        account_type: str,
+        active=False,
+        account_model: Optional[AccountModel] = None,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        bank_account_model_kwargs: Optional[Dict] = None,
+        commit: bool = True,
+    ):
         """
         Create a bank account entry for the entity model with specified attributes and validation.
 
@@ -2042,13 +2200,14 @@ class EntityModelAbstract(MP_Node,
 
         if account_type not in BankAccountModel.VALID_ACCOUNT_TYPES:
             raise EntityModelValidationError(
-                _(f'Invalid Account Type: choices are {BankAccountModel.VALID_ACCOUNT_TYPES}'))
+                _(
+                    f'Invalid Account Type: choices are {BankAccountModel.VALID_ACCOUNT_TYPES}'
+                )
+            )
 
         account_model_qs = self.get_coa_accounts(coa_model=coa_model, active=True)
         account_model_qs = account_model_qs.with_roles(
-            roles=[
-                BankAccountModel.ACCOUNT_TYPE_DEFAULT_ROLE_MAPPING[account_type]
-            ]
+            roles=[BankAccountModel.ACCOUNT_TYPE_DEFAULT_ROLE_MAPPING[account_type]]
         ).is_role_default()
 
         bank_account_model = BankAccountModel(
@@ -2056,8 +2215,10 @@ class EntityModelAbstract(MP_Node,
             entity_model=self,
             account_type=account_type,
             active=active,
-            account_model=account_model_qs.get() if not account_model else account_model,
-            **bank_account_model_kwargs
+            account_model=account_model_qs.get()
+            if not account_model
+            else account_model,
+            **bank_account_model_kwargs,
         )
 
         bank_account_model.clean()
@@ -2066,7 +2227,9 @@ class EntityModelAbstract(MP_Node,
         return bank_account_model
 
     # #### ITEM MANAGEMENT ###
-    def validate_item_qs(self, item_qs: ItemModelQuerySet, raise_exception: bool = True) -> bool:
+    def validate_item_qs(
+        self, item_qs: ItemModelQuerySet, raise_exception: bool = True
+    ) -> bool:
         """
         Validates the given ItemModelQuerySet against the EntityModel instance.
         Parameters
@@ -2084,7 +2247,9 @@ class EntityModelAbstract(MP_Node,
         for item_model in item_qs:
             if item_model.entity_id != self.uuid:
                 if raise_exception:
-                    raise EntityModelValidationError(f'Invalid item_qs provided for entity {self.slug}...')
+                    raise EntityModelValidationError(
+                        f'Invalid item_qs provided for entity {self.slug}...'
+                    )
                 return False
         return True
 
@@ -2098,7 +2263,9 @@ class EntityModelAbstract(MP_Node,
         """
         return self.unitofmeasuremodel_set.all().select_related('entity')
 
-    def create_uom(self, name: str, unit_abbr: str, active: bool = True, commit: bool = True) -> UnitOfMeasureModel:
+    def create_uom(
+        self, name: str, unit_abbr: str, active: bool = True, commit: bool = True
+    ) -> UnitOfMeasureModel:
         """
         Creates a new Unit of Measure Model associated with the EntityModel instance
 
@@ -2118,10 +2285,7 @@ class EntityModelAbstract(MP_Node,
         UnitOfMeasureModel
         """
         uom_model = UnitOfMeasureModel(
-            name=name,
-            unit_abbr=unit_abbr,
-            is_active=active,
-            entity=self
+            name=name, unit_abbr=unit_abbr, is_active=active, entity=self
         )
         uom_model.clean()
         uom_model.clean_fields()
@@ -2150,7 +2314,7 @@ class EntityModelAbstract(MP_Node,
             'inventory_account',
             'cogs_account',
             'earnings_account',
-            'expense_account'
+            'expense_account',
         )
         if active:
             return qs.active()
@@ -2174,12 +2338,14 @@ class EntityModelAbstract(MP_Node,
         qs = self.get_items_all(active=active)
         return qs.products()
 
-    def create_item_product(self,
-                            name: str,
-                            item_type: str,
-                            uom_model: Union[UUID, UnitOfMeasureModel],
-                            coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                            commit: bool = True) -> ItemModel:
+    def create_item_product(
+        self,
+        name: str,
+        item_type: str,
+        uom_model: Union[UUID, UnitOfMeasureModel],
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        commit: bool = True,
+    ) -> ItemModel:
         """
         Creates a new items of type PRODUCT.
 
@@ -2201,18 +2367,23 @@ class EntityModelAbstract(MP_Node,
             The created Product.
         """
         if isinstance(uom_model, UUID):
-            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(uuid__exact=uom_model)
+            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(
+                uuid__exact=uom_model
+            )
         elif isinstance(uom_model, UnitOfMeasureModel):
             if uom_model.entity_id != self.uuid:
-                raise EntityModelValidationError(f'Invalid UnitOfMeasureModel for entity {self.slug}...')
+                raise EntityModelValidationError(
+                    f'Invalid UnitOfMeasureModel for entity {self.slug}...'
+                )
 
         account_model_qs = self.get_coa_accounts(coa_model=coa_model, active=True)
         account_model_qs = account_model_qs.with_roles(
             roles=[
                 roles_module.ASSET_CA_INVENTORY,
                 roles_module.COGS,
-                roles_module.INCOME_OPERATIONAL
-            ]).is_role_default()
+                roles_module.INCOME_OPERATIONAL,
+            ]
+        ).is_role_default()
 
         # evaluates the queryset...
         len(account_model_qs)
@@ -2223,9 +2394,13 @@ class EntityModelAbstract(MP_Node,
             uom=uom_model,
             item_role=ItemModel.ITEM_ROLE_PRODUCT,
             item_type=item_type,
-            inventory_account=account_model_qs.filter(role=roles_module.ASSET_CA_INVENTORY).get(),
-            earnings_account=account_model_qs.filter(role=roles_module.INCOME_OPERATIONAL).get(),
-            cogs_account=account_model_qs.filter(role=roles_module.COGS).get()
+            inventory_account=account_model_qs.filter(
+                role=roles_module.ASSET_CA_INVENTORY
+            ).get(),
+            earnings_account=account_model_qs.filter(
+                role=roles_module.INCOME_OPERATIONAL
+            ).get(),
+            cogs_account=account_model_qs.filter(role=roles_module.COGS).get(),
         )
         product_model.clean()
         product_model.clean_fields()
@@ -2251,11 +2426,13 @@ class EntityModelAbstract(MP_Node,
         qs = self.get_items_all(active=active)
         return qs.services()
 
-    def create_item_service(self,
-                            name: str,
-                            uom_model: Union[UUID, UnitOfMeasureModel],
-                            coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                            commit: bool = True) -> ItemModel:
+    def create_item_service(
+        self,
+        name: str,
+        uom_model: Union[UUID, UnitOfMeasureModel],
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        commit: bool = True,
+    ) -> ItemModel:
         """
         Creates a new items of type SERVICE.
 
@@ -2277,17 +2454,19 @@ class EntityModelAbstract(MP_Node,
         """
 
         if isinstance(uom_model, UUID):
-            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(uuid__exact=uom_model)
+            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(
+                uuid__exact=uom_model
+            )
         elif isinstance(uom_model, UnitOfMeasureModel):
             if uom_model.entity_id != self.uuid:
-                raise EntityModelValidationError(f'Invalid UnitOfMeasureModel for entity {self.slug}...')
+                raise EntityModelValidationError(
+                    f'Invalid UnitOfMeasureModel for entity {self.slug}...'
+                )
 
         account_model_qs = self.get_coa_accounts(coa_model=coa_model, active=True)
         account_model_qs = account_model_qs.with_roles(
-            roles=[
-                roles_module.COGS,
-                roles_module.INCOME_OPERATIONAL
-            ]).is_role_default()
+            roles=[roles_module.COGS, roles_module.INCOME_OPERATIONAL]
+        ).is_role_default()
 
         # evaluates the queryset...
         len(account_model_qs)
@@ -2298,8 +2477,10 @@ class EntityModelAbstract(MP_Node,
             uom=uom_model,
             item_role=ItemModel.ITEM_ROLE_SERVICE,
             item_type=ItemModel.ITEM_TYPE_LABOR,
-            earnings_account=account_model_qs.filter(role=roles_module.INCOME_OPERATIONAL).get(),
-            cogs_account=account_model_qs.filter(role=roles_module.COGS).get()
+            earnings_account=account_model_qs.filter(
+                role=roles_module.INCOME_OPERATIONAL
+            ).get(),
+            cogs_account=account_model_qs.filter(role=roles_module.COGS).get(),
         )
         service_model.clean()
         service_model.clean_fields()
@@ -2325,14 +2506,15 @@ class EntityModelAbstract(MP_Node,
         qs = self.get_items_all(active=active)
         return qs.expenses()
 
-    def create_item_expense(self,
-                            name: str,
-                            expense_type: str,
-                            uom_model: Union[UUID, UnitOfMeasureModel],
-                            expense_account: Optional[Union[UUID, AccountModel]] = None,
-                            coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                            commit: bool = True) -> ItemModel:
-
+    def create_item_expense(
+        self,
+        name: str,
+        expense_type: str,
+        uom_model: Union[UUID, UnitOfMeasureModel],
+        expense_account: Optional[Union[UUID, AccountModel]] = None,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        commit: bool = True,
+    ) -> ItemModel:
         """
         Creates a new items of type EXPENSE.
 
@@ -2357,10 +2539,14 @@ class EntityModelAbstract(MP_Node,
         ItemModel
         """
         if isinstance(uom_model, UUID):
-            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(uuid__exact=uom_model)
+            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(
+                uuid__exact=uom_model
+            )
         elif isinstance(uom_model, UnitOfMeasureModel):
             if uom_model.entity_id != self.uuid:
-                raise EntityModelValidationError(f'Invalid UnitOfMeasureModel for entity {self.slug}...')
+                raise EntityModelValidationError(
+                    f'Invalid UnitOfMeasureModel for entity {self.slug}...'
+                )
 
         account_model_qs = self.get_coa_accounts(coa_model=coa_model, active=True)
         account_model_qs = account_model_qs.with_roles(
@@ -2372,7 +2558,9 @@ class EntityModelAbstract(MP_Node,
             expense_account = account_model_qs.get(uuid__exact=expense_account)
         elif isinstance(expense_account, AccountModel):
             if expense_account.coa_model.entity_id != self.uuid:
-                raise EntityModelValidationError(f'Invalid account for entity {self.slug}...')
+                raise EntityModelValidationError(
+                    f'Invalid account for entity {self.slug}...'
+                )
 
         expense_item_model = ItemModel(
             entity=self,
@@ -2380,7 +2568,7 @@ class EntityModelAbstract(MP_Node,
             uom=uom_model,
             item_role=ItemModel.ITEM_ROLE_EXPENSE,
             item_type=expense_type,
-            expense_account=expense_account
+            expense_account=expense_account,
         )
         expense_item_model.clean()
         expense_item_model.clean_fields()
@@ -2426,13 +2614,15 @@ class EntityModelAbstract(MP_Node,
         qs = self.get_items_all(active=active)
         return qs.inventory_wip()
 
-    def create_item_inventory(self,
-                              name: str,
-                              uom_model: Union[UUID, UnitOfMeasureModel],
-                              item_type: str,
-                              inventory_account: Optional[Union[UUID, AccountModel]] = None,
-                              coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                              commit: bool = True):
+    def create_item_inventory(
+        self,
+        name: str,
+        uom_model: Union[UUID, UnitOfMeasureModel],
+        item_type: str,
+        inventory_account: Optional[Union[UUID, AccountModel]] = None,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        commit: bool = True,
+    ):
         """
         Creates a new items of type INVENTORY.
 
@@ -2458,10 +2648,14 @@ class EntityModelAbstract(MP_Node,
         ItemModel
         """
         if isinstance(uom_model, UUID):
-            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(uuid__exact=uom_model)
+            uom_model = self.unitofmeasuremodel_set.select_related('entity').get(
+                uuid__exact=uom_model
+            )
         elif isinstance(uom_model, UnitOfMeasureModel):
             if uom_model.entity_id != self.uuid:
-                raise EntityModelValidationError(f'Invalid UnitOfMeasureModel for entity {self.slug}...')
+                raise EntityModelValidationError(
+                    f'Invalid UnitOfMeasureModel for entity {self.slug}...'
+                )
 
         account_model_qs = self.get_coa_accounts(coa_model=coa_model, active=True)
         account_model_qs = account_model_qs.with_roles(
@@ -2473,9 +2667,13 @@ class EntityModelAbstract(MP_Node,
             inventory_account = account_model_qs.get(uuid__exact=inventory_account)
         elif isinstance(inventory_account, AccountModel):
             if inventory_account.coa_model.entity_id != self.uuid:
-                raise EntityModelValidationError(f'Invalid account for entity {self.slug}...')
+                raise EntityModelValidationError(
+                    f'Invalid account for entity {self.slug}...'
+                )
             elif inventory_account.coa_model_id != coa_model.uuid:
-                raise EntityModelValidationError(f'Invalid account for coa {coa_model.slug}...')
+                raise EntityModelValidationError(
+                    f'Invalid account for coa {coa_model.slug}...'
+                )
 
         inventory_item_model = ItemModel(
             name=name,
@@ -2483,7 +2681,7 @@ class EntityModelAbstract(MP_Node,
             entity=self,
             item_type=item_type,
             item_role=ItemModel.ITEM_ROLE_INVENTORY,
-            inventory_account=inventory_account
+            inventory_account=inventory_account,
         )
         inventory_item_model.clean()
         inventory_item_model.clean_fields()
@@ -2523,42 +2721,49 @@ class EntityModelAbstract(MP_Node,
                 'count': i['quantity_onhand'],
                 'value': i['value_onhand'],
                 'avg_cost': i['cost_average']
-                if i['quantity_onhand'] else Decimal('0.00')
-            } for i in counted_qs
+                if i['quantity_onhand']
+                else Decimal('0.00'),
+            }
+            for i in counted_qs
         }
         recorded_map = {
             (i['uuid'], i['name'], i['uom__name']): {
                 'count': i['inventory_received'] or Decimal.from_float(0.0),
                 'value': i['inventory_received_value'] or Decimal.from_float(0.0),
                 'avg_cost': i['inventory_received_value'] / i['inventory_received']
-                if i['inventory_received'] else Decimal('0.00')
-            } for i in recorded_qs
+                if i['inventory_received']
+                else Decimal('0.00'),
+            }
+            for i in recorded_qs
         }
 
         # todo: change this to use a groupby then sum...
         item_ids = list(set(list(counted_map.keys()) + list(recorded_map)))
-        adjustment = defaultdict(lambda: {
-            # keeps track of inventory recounts...
-            'counted': Decimal('0.000'),
-            'counted_value': Decimal('0.00'),
-            'counted_avg_cost': Decimal('0.00'),
-
-            # keeps track of inventory level...
-            'recorded': Decimal('0.000'),
-            'recorded_value': Decimal('0.00'),
-            'recorded_avg_cost': Decimal('0.00'),
-
-            # keeps track of necessary inventory adjustment...
-            'count_diff': Decimal('0.000'),
-            'value_diff': Decimal('0.00'),
-            'avg_cost_diff': Decimal('0.00')
-        })
+        adjustment = defaultdict(
+            lambda: {
+                # keeps track of inventory recounts...
+                'counted': Decimal('0.000'),
+                'counted_value': Decimal('0.00'),
+                'counted_avg_cost': Decimal('0.00'),
+                # keeps track of inventory level...
+                'recorded': Decimal('0.000'),
+                'recorded_value': Decimal('0.00'),
+                'recorded_avg_cost': Decimal('0.00'),
+                # keeps track of necessary inventory adjustment...
+                'count_diff': Decimal('0.000'),
+                'value_diff': Decimal('0.00'),
+                'avg_cost_diff': Decimal('0.00'),
+            }
+        )
 
         for uid in item_ids:
-
             count_data = counted_map.get(uid)
             if count_data:
-                avg_cost = count_data['value'] / count_data['count'] if count_data['count'] else Decimal('0.000')
+                avg_cost = (
+                    count_data['value'] / count_data['count']
+                    if count_data['count']
+                    else Decimal('0.000')
+                )
 
                 adjustment[uid]['counted'] = count_data['count']
                 adjustment[uid]['counted_value'] = count_data['value']
@@ -2571,7 +2776,11 @@ class EntityModelAbstract(MP_Node,
             recorded_data = recorded_map.get(uid)
             if recorded_data:
                 counted = recorded_data['count']
-                avg_cost = recorded_data['value'] / counted if recorded_data['count'] else Decimal('0.000')
+                avg_cost = (
+                    recorded_data['value'] / counted
+                    if recorded_data['count']
+                    else Decimal('0.000')
+                )
 
                 adjustment[uid]['recorded'] = counted
                 adjustment[uid]['recorded_value'] = recorded_data['value']
@@ -2582,8 +2791,9 @@ class EntityModelAbstract(MP_Node,
                 adjustment[uid]['avg_cost_diff'] -= avg_cost
         return adjustment
 
-    def update_inventory(self,
-                         commit: bool = False) -> Tuple[defaultdict, ItemTransactionModelQuerySet, ItemModelQuerySet]:
+    def update_inventory(
+        self, commit: bool = False
+    ) -> Tuple[defaultdict, ItemTransactionModelQuerySet, ItemModelQuerySet]:
         """
         Triggers an inventory recount with optional commitment of transaction.
 
@@ -2603,9 +2813,13 @@ class EntityModelAbstract(MP_Node,
         ItemTransactionModel = lazy_loader.get_item_transaction_model()
         ItemModel = lazy_loader.get_item_model()
 
-        counted_qs: ItemTransactionModelQuerySet = ItemTransactionModel.objects.inventory_count(entity_slug=self.slug)
+        counted_qs: ItemTransactionModelQuerySet = (
+            ItemTransactionModel.objects.inventory_count(entity_model=self.slug)
+        )
         recorded_qs: ItemModelQuerySet = self.recorded_inventory(as_values=False)
-        recorded_qs_values = self.recorded_inventory(item_qs=recorded_qs, as_values=True)
+        recorded_qs_values = self.recorded_inventory(
+            item_qs=recorded_qs, as_values=True
+        )
 
         adj = self.inventory_adjustment(counted_qs, recorded_qs_values)
 
@@ -2618,18 +2832,16 @@ class EntityModelAbstract(MP_Node,
             updated_items.append(item_model)
 
         if commit:
-            ItemModel.objects.bulk_update(updated_items,
-                                          fields=[
-                                              'inventory_received',
-                                              'inventory_received_value',
-                                              'updated'
-                                          ])
+            ItemModel.objects.bulk_update(
+                updated_items,
+                fields=['inventory_received', 'inventory_received_value', 'updated'],
+            )
 
         return adj, counted_qs, recorded_qs
 
-    def recorded_inventory(self,
-                           item_qs: Optional[ItemModelQuerySet] = None,
-                           as_values: bool = True) -> ItemModelQuerySet:
+    def recorded_inventory(
+        self, item_qs: Optional[ItemModelQuerySet] = None, as_values: bool = True
+    ) -> ItemModelQuerySet:
         """
         Recorded inventory on the books marked as received. PurchaseOrderModel drives the ordering and receiving of
         inventory. Once inventory is marked as "received" recorded inventory of each item is updated by calling
@@ -2658,21 +2870,27 @@ class EntityModelAbstract(MP_Node,
             recorded_qs = item_qs
         if as_values:
             return recorded_qs.values(
-                'uuid', 'name', 'uom__name', 'inventory_received', 'inventory_received_value')
+                'uuid',
+                'name',
+                'uom__name',
+                'inventory_received',
+                'inventory_received_value',
+            )
         return recorded_qs
 
     # COMMON TRANSACTIONS...
-    def deposit_capital(self,
-                        amount: Union[Decimal, float],
-                        cash_account: Optional[Union[AccountModel, BankAccountModel]] = None,
-                        capital_account: Optional[AccountModel] = None,
-                        description: Optional[str] = None,
-                        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
-                        ledger_model: Optional[Union[LedgerModel, UUID]] = None,
-                        ledger_posted: bool = False,
-                        je_timestamp: Optional[Union[datetime, date, str]] = None,
-                        je_posted: bool = False):
-
+    def deposit_capital(
+        self,
+        amount: Union[Decimal, float],
+        cash_account: Optional[Union[AccountModel, BankAccountModel]] = None,
+        capital_account: Optional[AccountModel] = None,
+        description: Optional[str] = None,
+        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
+        ledger_model: Optional[Union[LedgerModel, UUID]] = None,
+        ledger_posted: bool = False,
+        je_timestamp: Optional[Union[datetime, date, str]] = None,
+        je_posted: bool = False,
+    ):
         if coa_model:
             self.validate_chart_of_accounts_for_entity(coa_model)
         else:
@@ -2697,16 +2915,28 @@ class EntityModelAbstract(MP_Node,
         if cash_account:
             if isinstance(cash_account, BankAccountModel):
                 cash_account = cash_account.account_model
-            self.validate_account_model_for_coa(account_model=cash_account, coa_model=coa_model)
-            self.validate_account_model_for_role(cash_account, roles_module.ASSET_CA_CASH)
+            self.validate_account_model_for_coa(
+                account_model=cash_account, coa_model=coa_model
+            )
+            self.validate_account_model_for_role(
+                cash_account, roles_module.ASSET_CA_CASH
+            )
         else:
-            cash_account = account_model_qs.filter(role__exact=roles_module.ASSET_CA_CASH).get()
+            cash_account = account_model_qs.filter(
+                role__exact=roles_module.ASSET_CA_CASH
+            ).get()
 
         if capital_account:
-            self.validate_account_model_for_coa(account_model=capital_account, coa_model=coa_model)
-            self.validate_account_model_for_role(capital_account, roles_module.EQUITY_CAPITAL)
+            self.validate_account_model_for_coa(
+                account_model=capital_account, coa_model=coa_model
+            )
+            self.validate_account_model_for_role(
+                capital_account, roles_module.EQUITY_CAPITAL
+            )
         else:
-            capital_account = account_model_qs.filter(role__exact=roles_module.EQUITY_CAPITAL).get()
+            capital_account = account_model_qs.filter(
+                role__exact=roles_module.EQUITY_CAPITAL
+            ).get()
 
         if not je_timestamp:
             je_timestamp = get_localtime()
@@ -2715,36 +2945,42 @@ class EntityModelAbstract(MP_Node,
             description = f'Capital Deposit on {je_timestamp.isoformat()}...'
 
         txs = list()
-        txs.append({
-            'account': cash_account,
-            'tx_type': DEBIT,
-            'amount': amount,
-            'description': description
-        })
-        txs.append({
-            'account': capital_account,
-            'tx_type': CREDIT,
-            'amount': amount,
-            'description': description
-        })
+        txs.append(
+            {
+                'account': cash_account,
+                'tx_type': DEBIT,
+                'amount': amount,
+                'description': description,
+            }
+        )
+        txs.append(
+            {
+                'account': capital_account,
+                'tx_type': CREDIT,
+                'amount': amount,
+                'description': description,
+            }
+        )
 
         if not ledger_model:
             ledger_model = self.ledgermodel_set.create(
                 name=f'Capital Deposit on {je_timestamp.isoformat()}.',
-                posted=ledger_posted
+                posted=ledger_posted,
             )
         else:
             if isinstance(ledger_model, LedgerModel):
                 self.validate_ledger_model_for_entity(ledger_model)
             else:
-                ledger_model_qs = LedgerModel.objects.filter(entity__uuid__exact=self.uuid)
+                ledger_model_qs = LedgerModel.objects.filter(
+                    entity__uuid__exact=self.uuid
+                )
                 ledger_model = ledger_model_qs.get(uuid__exact=ledger_model)
 
         self.commit_txs(
             je_timestamp=je_timestamp,
             je_txs=txs,
             je_posted=je_posted,
-            je_ledger_model=ledger_model
+            je_ledger_model=ledger_model,
         )
 
         return ledger_model
@@ -2756,14 +2992,22 @@ class EntityModelAbstract(MP_Node,
     def get_closing_entries(self):
         return self.closingentrymodel_set.all()
 
-    def get_closing_entry_dates_list_meta(self, as_iso: bool = True) -> List[Union[date, str]]:
+    def get_closing_entry_dates_list_meta(
+        self, as_iso: bool = True
+    ) -> List[Union[date, str]]:
         date_list = self.meta[self.META_KEY_CLOSING_ENTRY_DATES]
         if as_iso:
             return date_list
         return [date.fromisoformat(d) for d in date_list]
 
-    def compute_closing_entry_dates_list(self, as_iso: bool = True) -> List[Union[date, str]]:
-        closing_entry_qs = self.closingentrymodel_set.order_by('-closing_date').only('closing_date').posted()
+    def compute_closing_entry_dates_list(
+        self, as_iso: bool = True
+    ) -> List[Union[date, str]]:
+        closing_entry_qs = (
+            self.closingentrymodel_set.order_by('-closing_date')
+            .only('closing_date')
+            .posted()
+        )
         if as_iso:
             return [ce.closing_date.isoformat() for ce in closing_entry_qs]
         return [ce.closing_date for ce in closing_entry_qs]
@@ -2776,14 +3020,11 @@ class EntityModelAbstract(MP_Node,
         except IndexError:
             self.last_closing_date = None
 
-        self.meta[self.META_KEY_CLOSING_ENTRY_DATES] = [d.isoformat() for d in date_list]
+        self.meta[self.META_KEY_CLOSING_ENTRY_DATES] = [
+            d.isoformat() for d in date_list
+        ]
         if commit:
-            self.save(
-                update_fields=[
-                    'last_closing_date',
-                    'updated',
-                    'meta'
-                ])
+            self.save(update_fields=['last_closing_date', 'updated', 'meta'])
         return date_list
 
     def fetch_closing_entry_dates_meta(self, as_date: bool = True) -> List[date]:
@@ -2796,7 +3037,9 @@ class EntityModelAbstract(MP_Node,
             return self._CLOSING_ENTRY_DATES
         return date_list
 
-    def get_closing_entry_for_date(self, io_date: Union[date, datetime], inclusive: bool = True) -> Optional[date]:
+    def get_closing_entry_for_date(
+        self, io_date: Union[date, datetime], inclusive: bool = True
+    ) -> Optional[date]:
         if io_date is None:
             return
         ce_date_list = self.fetch_closing_entry_dates_meta()
@@ -2811,7 +3054,9 @@ class EntityModelAbstract(MP_Node,
         if ce_lookup in ce_date_list:
             return ce_lookup
 
-    def get_nearest_next_closing_entry(self, io_date: Union[date, datetime]) -> Optional[date]:
+    def get_nearest_next_closing_entry(
+        self, io_date: Union[date, datetime]
+    ) -> Optional[date]:
         if io_date is None:
             return
 
@@ -2819,10 +3064,12 @@ class EntityModelAbstract(MP_Node,
         if not len(ce_date_list):
             return
 
-        if all([
-            isinstance(io_date, date),
-            isinstance(io_date, datetime),
-        ]):
+        if all(
+            [
+                isinstance(io_date, date),
+                isinstance(io_date, datetime),
+            ]
+        ):
             io_date = io_date.date()
 
         if io_date > ce_date_list[0]:
@@ -2832,35 +3079,42 @@ class EntityModelAbstract(MP_Node,
             if p and p <= io_date < f:
                 return p
 
-    def close_entity_books(self,
-                           closing_date: Optional[date] = None,
-                           closing_entry_model=None,
-                           force_update: bool = False,
-                           post_closing_entry: bool = True):
-
+    def close_entity_books(
+        self,
+        closing_date: Optional[date] = None,
+        closing_entry_model=None,
+        force_update: bool = False,
+        post_closing_entry: bool = True,
+    ):
         if closing_entry_model and closing_date:
             raise EntityModelValidationError(
-                message=_('Closing books must be called by providing closing_date or closing_entry_model, not both.')
+                message=_(
+                    'Closing books must be called by providing closing_date or closing_entry_model, not both.'
+                )
             )
         elif not closing_date and not closing_entry_model:
             raise EntityModelValidationError(
-                message=_('Closing books must be called by providing closing_date or closing_entry_model.')
+                message=_(
+                    'Closing books must be called by providing closing_date or closing_entry_model.'
+                )
             )
 
         closing_entry_exists = False
 
         if closing_entry_model:
             closing_date = closing_entry_model.closing_date
-            self.validate_closing_entry_model(closing_entry_model, closing_date=closing_date)
+            self.validate_closing_entry_model(
+                closing_entry_model, closing_date=closing_date
+            )
             closing_entry_exists = True
         else:
             try:
-                closing_entry_model = self.closingentrymodel_set.select_related(
-                    'ledger_model',
-                    'ledger_model__entity'
-                ).defer(
-                    'markdown_notes').get(
-                    closing_date__exact=closing_date
+                closing_entry_model = (
+                    self.closingentrymodel_set.select_related(
+                        'ledger_model', 'ledger_model__entity'
+                    )
+                    .defer('markdown_notes')
+                    .get(closing_date__exact=closing_date)
                 )
 
                 closing_entry_exists = True
@@ -2879,27 +3133,44 @@ class EntityModelAbstract(MP_Node,
                 self.save_closing_entry_dates_meta(commit=True)
 
             return closing_entry_model, ce_txs
-        raise EntityModelValidationError(message=f'Closing Entry for Period {closing_date} already exists.')
+        raise EntityModelValidationError(
+            message=f'Closing Entry for Period {closing_date} already exists.'
+        )
 
-    def close_books_for_month(self, year: int, month: int, force_update: bool = False, post_closing_entry: bool = True):
+    def close_books_for_month(
+        self,
+        year: int,
+        month: int,
+        force_update: bool = False,
+        post_closing_entry: bool = True,
+    ):
         _, day = monthrange(year, month)
         closing_dt = date(year, month, day)
         return self.close_entity_books(
             closing_date=closing_dt,
             force_update=force_update,
             post_closing_entry=post_closing_entry,
-            closing_entry_model=None
+            closing_entry_model=None,
         )
 
-    def close_books_for_fiscal_year(self, fiscal_year: int, force_update: bool = False,
-                                    post_closing_entry: bool = True):
+    def close_books_for_fiscal_year(
+        self,
+        fiscal_year: int,
+        force_update: bool = False,
+        post_closing_entry: bool = True,
+    ):
         closing_dt = self.get_fy_end(year=fiscal_year)
-        return self.close_entity_books(closing_date=closing_dt, force_update=force_update,
-                                       post_closing_entry=post_closing_entry)
+        return self.close_entity_books(
+            closing_date=closing_dt,
+            force_update=force_update,
+            post_closing_entry=post_closing_entry,
+        )
 
     # ### RANDOM DATA GENERATION ####
 
-    def populate_random_data(self, start_date: date, days_forward=180, tx_quantity: int = 25):
+    def populate_random_data(
+        self, start_date: date, days_forward=180, tx_quantity: int = 25
+    ):
         EntityDataGenerator = lazy_loader.get_entity_data_generator()
         data_generator = EntityDataGenerator(
             user_model=self.admin,
@@ -2907,16 +3178,15 @@ class EntityModelAbstract(MP_Node,
             start_dttm=start_date,
             entity_model=self,
             capital_contribution=Decimal.from_float(50000.00),
-            tx_quantity=tx_quantity
+            tx_quantity=tx_quantity,
         )
         data_generator.populate_entity()
 
     # URLS ----
     def get_absolute_url(self):
-        return reverse(viewname='django_ledger:entity-dashboard',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse(
+            viewname='django_ledger:entity-dashboard', kwargs={'entity_slug': self.slug}
+        )
 
     def get_dashboard_url(self) -> str:
         """
@@ -2927,10 +3197,9 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel dashboard URL as a string.
         """
-        return reverse('django_ledger:entity-dashboard',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse(
+            'django_ledger:entity-dashboard', kwargs={'entity_slug': self.slug}
+        )
 
     def get_manage_url(self) -> str:
         """
@@ -2941,10 +3210,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel manage URL as a string.
         """
-        return reverse('django_ledger:entity-update',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:entity-update', kwargs={'entity_slug': self.slug})
 
     def get_ledgers_url(self) -> str:
         """
@@ -2955,10 +3221,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel ledger list URL as a string.
         """
-        return reverse('django_ledger:ledger-list',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:ledger-list', kwargs={'entity_slug': self.slug})
 
     def get_bills_url(self) -> str:
         """
@@ -2969,10 +3232,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel bill list URL as a string.
         """
-        return reverse('django_ledger:bill-list',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:bill-list', kwargs={'entity_slug': self.slug})
 
     def get_invoices_url(self) -> str:
         """
@@ -2983,10 +3243,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel invoice list URL as a string.
         """
-        return reverse('django_ledger:invoice-list',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:invoice-list', kwargs={'entity_slug': self.slug})
 
     def get_banks_url(self) -> str:
         """
@@ -2997,10 +3254,9 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel bank account list URL as a string.
         """
-        return reverse('django_ledger:bank-account-list',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse(
+            'django_ledger:bank-account-list', kwargs={'entity_slug': self.slug}
+        )
 
     def get_balance_sheet_url(self) -> str:
         """
@@ -3011,10 +3267,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel Balance Sheet Statement URL as a string.
         """
-        return reverse('django_ledger:entity-bs',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:entity-bs', kwargs={'entity_slug': self.slug})
 
     def get_income_statement_url(self) -> str:
         """
@@ -3025,10 +3278,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel Income Statement URL as a string.
         """
-        return reverse('django_ledger:entity-ic',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:entity-ic', kwargs={'entity_slug': self.slug})
 
     def get_cashflow_statement_url(self) -> str:
         """
@@ -3039,10 +3289,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel Cashflow Statement URL as a string.
         """
-        return reverse('django_ledger:entity-cf',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:entity-cf', kwargs={'entity_slug': self.slug})
 
     def get_data_import_url(self) -> str:
         """
@@ -3053,33 +3300,24 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel transaction import URL as a string.
         """
-        return reverse('django_ledger:data-import-jobs-list',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse(
+            'django_ledger:data-import-jobs-list', kwargs={'entity_slug': self.slug}
+        )
 
     def get_coa_list_url(self) -> str:
         return reverse(
-            viewname='django_ledger:coa-list',
-            kwargs={
-                'entity_slug': self.slug
-            }
+            viewname='django_ledger:coa-list', kwargs={'entity_slug': self.slug}
         )
 
     def get_coa_list_inactive_url(self) -> str:
         return reverse(
             viewname='django_ledger:coa-list-inactive',
-            kwargs={
-                'entity_slug': self.slug
-            }
+            kwargs={'entity_slug': self.slug},
         )
 
     def get_coa_create_url(self) -> str:
         return reverse(
-            viewname='django_ledger:coa-create',
-            kwargs={
-                'entity_slug': self.slug
-            }
+            viewname='django_ledger:coa-create', kwargs={'entity_slug': self.slug}
         )
 
     def get_accounts_url(self) -> str:
@@ -3091,10 +3329,12 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel Code of Accounts llist import URL as a string.
         """
-        return reverse('django_ledger:account-list',
-                       kwargs={
-                           'entity_slug': self.slug,
-                       })
+        return reverse(
+            'django_ledger:account-list',
+            kwargs={
+                'entity_slug': self.slug,
+            },
+        )
 
     def get_customers_url(self) -> str:
         """
@@ -3105,10 +3345,12 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel customers list URL as a string.
         """
-        return reverse('django_ledger:customer-list',
-                       kwargs={
-                           'entity_slug': self.slug,
-                       })
+        return reverse(
+            'django_ledger:customer-list',
+            kwargs={
+                'entity_slug': self.slug,
+            },
+        )
 
     def get_vendors_url(self) -> str:
         """
@@ -3119,10 +3361,12 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel vendors list URL as a string.
         """
-        return reverse('django_ledger:vendor-list',
-                       kwargs={
-                           'entity_slug': self.slug,
-                       })
+        return reverse(
+            'django_ledger:vendor-list',
+            kwargs={
+                'entity_slug': self.slug,
+            },
+        )
 
     def get_delete_url(self) -> str:
         """
@@ -3133,10 +3377,7 @@ class EntityModelAbstract(MP_Node,
         str
             EntityModel delete URL as a string.
         """
-        return reverse('django_ledger:entity-delete',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse('django_ledger:entity-delete', kwargs={'entity_slug': self.slug})
 
     def clean(self):
         if not self.slug:
@@ -3163,6 +3404,7 @@ class EntityStateModelAbstract(Model):
     KEY_VENDOR = 'vendor'
     KEY_CUSTOMER = 'customer'
     KEY_ITEM = 'item'
+    KEY_RECEIPT = 'receipt'
 
     KEY_CHOICES = [
         (KEY_JOURNAL_ENTRY, _('Journal Entry')),
@@ -3173,38 +3415,36 @@ class EntityStateModelAbstract(Model):
     ]
 
     uuid = models.UUIDField(default=uuid4, editable=False, primary_key=True)
-    entity_model = models.ForeignKey('django_ledger.EntityModel',
-                                     on_delete=models.CASCADE,
-                                     verbose_name=_('Entity Model'))
-    entity_unit = models.ForeignKey('django_ledger.EntityUnitModel',
-                                    on_delete=models.RESTRICT,
-                                    verbose_name=_('Entity Unit'),
-                                    blank=True,
-                                    null=True)
+    entity_model = models.ForeignKey(
+        'django_ledger.EntityModel',
+        on_delete=models.CASCADE,
+        verbose_name=_('Entity Model'),
+    )
+    entity_unit = models.ForeignKey(
+        'django_ledger.EntityUnitModel',
+        on_delete=models.RESTRICT,
+        verbose_name=_('Entity Unit'),
+        blank=True,
+        null=True,
+    )
     fiscal_year = models.SmallIntegerField(
         verbose_name=_('Fiscal Year'),
         validators=[MinValueValidator(limit_value=1900)],
         null=True,
-        blank=True
+        blank=True,
     )
     key = models.CharField(choices=KEY_CHOICES, max_length=10)
-    sequence = models.BigIntegerField(default=0, validators=[MinValueValidator(limit_value=0)])
+    sequence = models.BigIntegerField(
+        default=0, validators=[MinValueValidator(limit_value=0)]
+    )
 
     class Meta:
         abstract = True
         indexes = [
             models.Index(fields=['key']),
-            models.Index(
-                fields=[
-                    'entity_model',
-                    'fiscal_year',
-                    'entity_unit',
-                    'key'
-                ])
-        ]
-        unique_together = [
-            ('entity_model', 'entity_unit', 'fiscal_year', 'key')
+            models.Index(fields=['entity_model', 'fiscal_year', 'entity_unit', 'key']),
         ]
+        unique_together = [('entity_model', 'entity_unit', 'fiscal_year', 'key')]
 
     def __str__(self):
         return f'{self.__class__.__name__} {self.entity_model_id}: FY: {self.fiscal_year}, KEY: {self.get_key_display()}'
@@ -3224,31 +3464,38 @@ class EntityManagementModelAbstract(CreateUpdateMixIn):
     """
     Entity Management Model responsible for manager permissions to read/write.
     """
+
     PERMISSIONS = [
         ('read', _('Read Permissions')),
         ('write', _('Read/Write Permissions')),
-        ('suspended', _('No Permissions'))
+        ('suspended', _('No Permissions')),
     ]
 
     uuid = models.UUIDField(default=uuid4, editable=False, primary_key=True)
-    entity = models.ForeignKey('django_ledger.EntityModel',
-                               on_delete=models.CASCADE,
-                               verbose_name=_('Entity'),
-                               related_name='entity_permissions')
-    user = models.ForeignKey(UserModel,
-                             on_delete=models.CASCADE,
-                             verbose_name=_('Manager'),
-                             related_name='entity_permissions')
-    permission_level = models.CharField(max_length=10,
-                                        default='read',
-                                        choices=PERMISSIONS,
-                                        verbose_name=_('Permission Level'))
+    entity = models.ForeignKey(
+        'django_ledger.EntityModel',
+        on_delete=models.CASCADE,
+        verbose_name=_('Entity'),
+        related_name='entity_permissions',
+    )
+    user = models.ForeignKey(
+        UserModel,
+        on_delete=models.CASCADE,
+        verbose_name=_('Manager'),
+        related_name='entity_permissions',
+    )
+    permission_level = models.CharField(
+        max_length=10,
+        default='read',
+        choices=PERMISSIONS,
+        verbose_name=_('Permission Level'),
+    )
 
     class Meta:
         abstract = True
         indexes = [
             models.Index(fields=['entity', 'user']),
-            models.Index(fields=['user', 'entity'])
+            models.Index(fields=['user', 'entity']),
         ]