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

django_ledger/models/unit.py

@@ -21,14 +21,15 @@ Key advantages of EntityUnits:
        business units.
 """
 
+import warnings
 from random import choices
-from string import ascii_lowercase, digits, ascii_uppercase
+from string import ascii_lowercase, ascii_uppercase, digits
 from typing import Optional
-from uuid import uuid4
+from uuid import UUID, uuid4
 
 from django.core.exceptions import ValidationError
 from django.db import models
-from django.db.models import Q, F
+from django.db.models import F, Q
 from django.urls import reverse
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
@@ -36,7 +37,9 @@ from treebeard.mp_tree import MP_Node, MP_NodeManager, MP_NodeQuerySet
 
 from django_ledger.io.io_core import IOMixIn
 from django_ledger.models import lazy_loader
+from django_ledger.models.deprecations import deprecated_entity_slug_behavior
 from django_ledger.models.mixins import CreateUpdateMixIn, SlugNameMixIn
+from django_ledger.settings import DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR
 
 ENTITY_UNIT_RANDOM_SLUG_SUFFIX = ascii_lowercase + digits
 
@@ -46,13 +49,15 @@ class EntityUnitModelValidationError(ValidationError):
 
 
 class EntityUnitModelQuerySet(MP_NodeQuerySet):
-    """
-    A custom defined EntityUnitModel Queryset.
-    """
+    def for_user(self, user_model) -> 'EntityUnitModelQuerySet':
+        if user_model.is_superuser:
+            return self
+        return self.filter(
+            Q(entity__admin=user_model) | Q(entity__managers__in=[user_model])
+        )
 
 
 class EntityUnitModelManager(MP_NodeManager):
-
     def get_queryset(self):
         qs = EntityUnitModelQuerySet(self.model, using=self._db)
         return qs.annotate(
@@ -60,47 +65,64 @@ class EntityUnitModelManager(MP_NodeManager):
             _entity_name=F('entity__name'),
         )
 
-    def for_user(self, user_model):
-        qs = self.get_queryset()
-        if user_model.is_superuser:
-            return qs
-        return qs.filter(
-            Q(entity__admin=user_model) |
-            Q(entity__managers__in=[user_model])
-        )
-
-    def for_entity(self, entity_slug: str, user_model):
+    @deprecated_entity_slug_behavior
+    def for_entity(self, entity_model: 'EntityModel | str | UUID' = None, **kwargs):
         """
-        Fetches a QuerySet of EntityUnitModels associated with a specific EntityModel & UserModel.
-        May pass an instance of EntityModel or a String representing the EntityModel slug.
+        Filter the queryset based on the provided entity model, its slug, or its UUID.
+
+        Provides functionality to filter entities within a queryset by comparing either
+        an EntityModel instance, its slug, or its UUID. This method also handles optional
+        deprecated behavior for filtering by the 'user_model' for backward compatibility.
 
         Parameters
         ----------
-        entity_slug: str or EntityModel
-            The entity slug or EntityModel used for filtering the QuerySet.
-        user_model
-            Logged in and authenticated django UserModel instance.
+        entity_model : EntityModel | str | UUID
+            An entity filter criterion that could be a specific EntityModel instance, a
+            string representing the entity slug, or a UUID corresponding to the entity.
+
+        **kwargs : dict, optional
+            Additional keyword arguments. If the 'user_model' parameter is provided,
+            a deprecation warning is issued, and the functionality temporarily delegates
+            to legacy behavior based on the value of 'DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR'.
 
         Returns
         -------
-        EntityUnitModelQuerySet
-            Returns a EntityUnitModelQuerySet with applied filters.
+        QuerySet
+            A queryset filtered based on the provided entity criteria.
+
+        Raises
+        ------
+        EntityUnitModelValidationError
+            Raised when the `entity_model` parameter does not match any of the accepted types
+            (EntityModel, str, or UUID) and fails validation.
         """
-        qs = self.for_user(user_model)
-        if isinstance(entity_slug, lazy_loader.get_entity_model()):
-            return qs.filter(
-                Q(entity=entity_slug)
+        EntityModel = lazy_loader.get_entity_model()
 
+        qs = self.get_queryset()
+        if 'user_model' in kwargs:
+            warnings.warn(
+                'user_model parameter is deprecated and will be removed in a future release. '
+                'Use for_user(user_model).for_entity(entity_model) instead to keep current behavior.',
+                DeprecationWarning,
+                stacklevel=2,
             )
-        return qs.filter(
-            Q(entity__slug__exact=entity_slug)
-        )
+            if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+                qs = qs.for_user(kwargs['user_model'])
+
+        if isinstance(entity_model, EntityModel):
+            qs = qs.filter(entity=entity_model)
+        elif isinstance(entity_model, str):
+            qs = qs.filter(entity__slug__exact=entity_model)
+        elif isinstance(entity_model, UUID):
+            qs = qs.filter(entity_id=entity_model)
+        else:
+            raise EntityUnitModelValidationError(
+                message='Must pass EntityModel, slug or UUID'
+            )
+        return qs
 
 
-class EntityUnitModelAbstract(MP_Node,
-                              IOMixIn,
-                              SlugNameMixIn,
-                              CreateUpdateMixIn):
+class EntityUnitModelAbstract(MP_Node, IOMixIn, SlugNameMixIn, CreateUpdateMixIn):
     """
     Base implementation of the EntityUnitModel.
 
@@ -125,17 +147,22 @@ class EntityUnitModelAbstract(MP_Node,
     hidden: bool
         Hidden Units will not show on drop down menus on the UI. Defaults to False.
     """
+
     uuid = models.UUIDField(default=uuid4, editable=False, primary_key=True)
     slug = models.SlugField(max_length=50)
-    entity = models.ForeignKey('django_ledger.EntityModel',
-                               editable=False,
-                               on_delete=models.CASCADE,
-                               verbose_name=_('Unit Entity'))
+    entity = models.ForeignKey(
+        'django_ledger.EntityModel',
+        editable=False,
+        on_delete=models.CASCADE,
+        verbose_name=_('Unit Entity'),
+    )
     document_prefix = models.CharField(max_length=3)
     active = models.BooleanField(default=True, verbose_name=_('Is Active'))
     hidden = models.BooleanField(default=False, verbose_name=_('Is Hidden'))
 
-    objects = EntityUnitModelManager.from_queryset(queryset_class=EntityUnitModelQuerySet)()
+    objects = EntityUnitModelManager.from_queryset(
+        queryset_class=EntityUnitModelQuerySet
+    )()
 
     class Meta:
         abstract = True
@@ -185,19 +212,20 @@ class EntityUnitModelAbstract(MP_Node,
         str
             The EntityModelUnit instance dashboard URL.
         """
-        return reverse('django_ledger:unit-dashboard',
-                       kwargs={
-                           'entity_slug': self.slug
-                       })
+        return reverse(
+            'django_ledger:unit-dashboard', kwargs={'entity_slug': self.slug}
+        )
 
     def get_entity_name(self) -> str:
         return self.entity.name
 
-    def create_entity_unit_slug(self,
-                                name: Optional[str] = None,
-                                force: bool = False,
-                                add_suffix: bool = True,
-                                k: int = 5) -> str:
+    def create_entity_unit_slug(
+        self,
+        name: Optional[str] = None,
+        force: bool = False,
+        add_suffix: bool = True,
+        k: int = 5,
+    ) -> str:
         """
         Automatically generates a EntityUnitModel slug. If slug is present, will not be replaced.
         Called during the clean() method.
@@ -228,13 +256,24 @@ class EntityUnitModelAbstract(MP_Node,
             self.slug = unit_slug
         return self.slug
 
+    def validate_for_entity(self, entity_model: 'EntityModel | str | UUID'):
+        EntityModel = lazy_loader.get_entity_model()
+
+        if isinstance(entity_model, UUID):
+            is_valid = self.entity_id == entity_model
+        elif isinstance(entity_model, str):
+            is_valid = self.entity_slug == entity_model
+        elif isinstance(entity_model, EntityModel):
+            is_valid = self.entity == entity_model
+        if not is_valid:
+            raise EntityUnitModelValidationError(
+                f'Entity Unit Model {entity_model} is not a valid Entity Model'
+            )
+
     def get_absolute_url(self):
         return reverse(
             viewname='django_ledger:unit-detail',
-            kwargs={
-                'entity_slug': self.entity.slug,
-                'unit_slug': self.slug
-            }
+            kwargs={'entity_slug': self.entity.slug, 'unit_slug': self.slug},
         )
 
 

django_ledger/models/utils.py

@@ -75,6 +75,7 @@ class LazyLoader:
     LEDGER_MODEL = 'ledgermodel'
     JE_MODEL = 'journalentrymodel'
     TRANSACTION_MODEL = 'transactionmodel'
+    STAGED_TRANSACTION_MODEL = 'stagedtransactionmodel'
     ACCOUNT_MODEL = 'accountmodel'
     COA_MODEL = 'chartofaccountmodel'
 
@@ -88,6 +89,7 @@ class LazyLoader:
 
     CUSTOMER_MODEL = 'customermodel'
     INVOICE_MODEL = 'invoicemodel'
+    RECEIPT_MODEL = 'receiptmodel'
     BILL_MODEL = 'billmodel'
     UOM_MODEL = 'unitofmeasuremodel'
     VENDOR_MODEL = 'vendormodel'
@@ -100,8 +102,6 @@ class LazyLoader:
     INCOME_STATEMENT_REPORT_CLASS = None
     CASH_FLOW_STATEMENT_REPORT_CLASS = None
 
-
-
     def get_entity_model(self):
         return self.app_config.get_model(self.ENTITY_MODEL)
 
@@ -123,6 +123,9 @@ class LazyLoader:
     def get_txs_model(self):
         return self.app_config.get_model(self.TRANSACTION_MODEL)
 
+    def get_staged_txs_model(self):
+        return self.app_config.get_model(self.STAGED_TRANSACTION_MODEL)
+
     def get_purchase_order_model(self):
         return self.app_config.get_model(self.PURCHASE_ORDER_MODEL)
 
@@ -139,6 +142,9 @@ class LazyLoader:
     def get_item_transaction_model(self):
         return self.app_config.get_model(self.ITEM_TRANSACTION_MODEL)
 
+    def get_receipt_model(self):
+        return self.app_config.get_model(self.RECEIPT_MODEL)
+
     def get_customer_model(self):
         return self.app_config.get_model(self.CUSTOMER_MODEL)
 
@@ -166,24 +172,28 @@ class LazyLoader:
     def get_entity_data_generator(self):
         if not self.ENTITY_DATA_GENERATOR:
             from django_ledger.io.io_generator import EntityDataGenerator
+
             self.ENTITY_DATA_GENERATOR = EntityDataGenerator
         return self.ENTITY_DATA_GENERATOR
 
     def get_balance_sheet_report_class(self):
         if not self.BALANCE_SHEET_REPORT_CLASS:
             from django_ledger.report.balance_sheet import BalanceSheetReport
+
             self.BALANCE_SHEET_REPORT_CLASS = BalanceSheetReport
         return self.BALANCE_SHEET_REPORT_CLASS
 
     def get_income_statement_report_class(self):
         if not self.INCOME_STATEMENT_REPORT_CLASS:
             from django_ledger.report.income_statement import IncomeStatementReport
+
             self.INCOME_STATEMENT_REPORT_CLASS = IncomeStatementReport
         return self.INCOME_STATEMENT_REPORT_CLASS
 
     def get_cash_flow_statement_report_class(self):
         if not self.CASH_FLOW_STATEMENT_REPORT_CLASS:
             from django_ledger.report.cash_flow_statement import CashFlowStatementReport
+
             self.CASH_FLOW_STATEMENT_REPORT_CLASS = CashFlowStatementReport
         return self.CASH_FLOW_STATEMENT_REPORT_CLASS
 

django_ledger/models/vendor.py

@@ -10,18 +10,30 @@ Vendors can be flagged as active/inactive or hidden. Vendors who no longer condu
 whether temporarily or indefinitely may be flagged as inactive (i.e. active is False). Hidden Vendors will not show up
 as an option in the UI, but can still be used programmatically (via API).
 """
+
 import os
-from uuid import uuid4
+import warnings
+from uuid import UUID, uuid4
 
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
-from django.db import models, transaction, IntegrityError
-from django.db.models import Q, F, QuerySet, Manager
+from django.db import IntegrityError, models, transaction
+from django.db.models import F, Manager, Q, QuerySet
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
 
-from django_ledger.models.mixins import ContactInfoMixIn, CreateUpdateMixIn, FinancialAccountInfoMixin, TaxInfoMixIn
+from django_ledger.models.deprecations import deprecated_entity_slug_behavior
+from django_ledger.models.mixins import (
+    ContactInfoMixIn,
+    CreateUpdateMixIn,
+    FinancialAccountInfoMixin,
+    TaxInfoMixIn,
+)
 from django_ledger.models.utils import lazy_loader
-from django_ledger.settings import DJANGO_LEDGER_DOCUMENT_NUMBER_PADDING, DJANGO_LEDGER_VENDOR_NUMBER_PREFIX
+from django_ledger.settings import (
+    DJANGO_LEDGER_DOCUMENT_NUMBER_PADDING,
+    DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR,
+    DJANGO_LEDGER_VENDOR_NUMBER_PREFIX,
+)
 
 
 def vendor_picture_upload_to(instance, filename):
@@ -42,7 +54,15 @@ class VendorModelQuerySet(QuerySet):
     Custom defined VendorModel QuerySet.
     """
 
-    def active(self) -> QuerySet:
+    def for_user(self, user_model) -> 'VendorModelQuerySet':
+        if user_model.is_superuser:
+            return self
+        return self.filter(
+            Q(entity_model__admin=user_model)
+            | Q(entity_model__managers__in=[user_model])
+        )
+
+    def active(self) -> 'VendorModelQuerySet':
         """
         Active vendors can be assigned to new bills and show on dropdown menus and views.
 
@@ -53,7 +73,7 @@ class VendorModelQuerySet(QuerySet):
         """
         return self.filter(active=True)
 
-    def inactive(self) -> QuerySet:
+    def inactive(self) -> 'VendorModelQuerySet':
         """
         Active vendors can be assigned to new bills and show on dropdown menus and views.
         Marking VendorModels as inactive can help reduce Database load to populate select inputs and also inactivate
@@ -67,7 +87,7 @@ class VendorModelQuerySet(QuerySet):
         """
         return self.filter(active=False)
 
-    def hidden(self) -> QuerySet:
+    def hidden(self) -> 'VendorModelQuerySet':
         """
         Hidden vendors do not show on dropdown menus, but may be used via APIs or any other method that does not
         involve the UI.
@@ -79,7 +99,7 @@ class VendorModelQuerySet(QuerySet):
         """
         return self.filter(hidden=True)
 
-    def visible(self) -> QuerySet:
+    def visible(self) -> 'VendorModelQuerySet':
         """
         Visible vendors show on dropdown menus and views. Visible vendors are active and not hidden.
 
@@ -88,62 +108,79 @@ class VendorModelQuerySet(QuerySet):
         VendorModelQuerySet
             A QuerySet of visible Vendors.
         """
-        return self.filter(
-            Q(hidden=False) & Q(active=True)
-        )
+        return self.filter(Q(hidden=False) & Q(active=True))
 
 
 class VendorModelManager(Manager):
     """
-    Custom defined VendorModel Manager, which defines many methods for initial query of the Database.
-    """
+    Manages operations related to VendorModel instances.
 
-    def for_user(self, user_model):
-        qs = self.get_queryset()
-        if user_model.is_superuser:
-            return qs
-        return qs.filter(
-            Q(entity_model__admin=user_model) |
-            Q(entity_model__managers__in=[user_model])
-        )
+    A specialized manager for handling interactions with VendorModel entities,
+    providing additional support for filtering based on associated EntityModel or EntityModel slug.
+    """
 
-    def for_entity(self, entity_slug, user_model) -> VendorModelQuerySet:
+    @deprecated_entity_slug_behavior
+    def for_entity(
+        self, entity_model: 'EntityModel | str | UUID' = None, **kwargs
+    ) -> VendorModelQuerySet:
         """
-        Fetches a QuerySet of VendorModel associated with a specific EntityModel & UserModel.
-        May pass an instance of EntityModel or a String representing the EntityModel slug.
+        Filters the queryset for a given entity model.
+
+        This method modifies the queryset to include only those records
+        associated with the specified entity model. The entity model can
+        be provided in various formats, such as an instance of `EntityModel`,
+        a string representing the entity's slug, or its UUID.
+
+        If a deprecated parameter `user_model` is provided, it will issue
+        a warning and may alter the behavior if the deprecated behavior flag
+        `DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR` is set.
 
         Parameters
         ----------
-        entity_slug: str or EntityModel
-            The entity slug or EntityModel used for filtering the QuerySet.
-        user_model
-            Logged in and authenticated django UserModel instance.
+        entity_model : EntityModel | str | UUID
+            The entity model or its identifier (slug or UUID) to filter the
+            queryset by.
 
-        Examples
-        ________
-            >>> request_user = request.user
-            >>> slug = kwargs['entity_slug'] # may come from request kwargs
-            >>> vendor_model_qs = VendorModel.objects.for_entity(user_model=request_user, entity_slug=slug)
+        **kwargs
+            Additional parameters for optional functionality. The parameter
+            `user_model` is supported for backward compatibility but is
+            deprecated and should be avoided.
 
         Returns
         -------
         VendorModelQuerySet
-            A filtered VendorModel QuerySet.
+            A queryset filtered for the given entity model.
         """
-        qs = self.for_user(user_model)
-        if isinstance(entity_slug, lazy_loader.get_entity_model()):
-            return qs.filter(
-                Q(entity_model=entity_slug)
+        EntityModel = lazy_loader.get_entity_model()
+
+        qs = self.get_queryset()
+        if 'user_model' in kwargs:
+            warnings.warn(
+                'user_model parameter is deprecated and will be removed in a future release. '
+                'Use for_user(user_model).for_entity(entity_model) instead to keep current behavior.',
+                DeprecationWarning,
+                stacklevel=2,
             )
-        return qs.filter(
-            Q(entity_model__slug__exact=entity_slug)
-        )
 
+            if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+                qs = qs.for_user(kwargs['user_model'])
+
+        if isinstance(entity_model, EntityModel):
+            qs = qs.filter(entity_model=entity_model)
+        elif isinstance(entity_model, str):
+            qs = qs.filter(entity_model__slug__exact=entity_model)
+        elif isinstance(entity_model, UUID):
+            qs = qs.filter(entity_model_id=entity_model)
+        else:
+            raise VendorModelValidationError(
+                'EntityModel slug must be either a string or an EntityModel instance'
+            )
+        return qs
 
-class VendorModelAbstract(ContactInfoMixIn,
-                          FinancialAccountInfoMixin,
-                          TaxInfoMixIn,
-                          CreateUpdateMixIn):
+
+class VendorModelAbstract(
+    ContactInfoMixIn, FinancialAccountInfoMixin, TaxInfoMixIn, CreateUpdateMixIn
+):
     """
     This is the main abstract class which the VendorModel database will inherit from.
     The VendorModel inherits functionality from the following MixIns:
@@ -182,28 +219,33 @@ class VendorModelAbstract(ContactInfoMixIn,
 
 
     """
+
     uuid = models.UUIDField(default=uuid4, editable=False, primary_key=True)
     vendor_code = models.SlugField(
-        max_length=50,
+        max_length=50, null=True, blank=True, verbose_name='User defined vendor code.'
+    )
+    vendor_number = models.CharField(
+        max_length=30,
         null=True,
         blank=True,
-        verbose_name='User defined vendor code.'
+        editable=False,
+        verbose_name=_('Vendor Number'),
+        help_text='System generated vendor number.',
     )
-    vendor_number = models.CharField(max_length=30,
-                                     null=True,
-                                     blank=True,
-                                     editable=False,
-                                     verbose_name=_('Vendor Number'), help_text='System generated vendor number.')
     vendor_name = models.CharField(max_length=100)
 
-    entity_model = models.ForeignKey('django_ledger.EntityModel',
-                                     on_delete=models.CASCADE,
-                                     verbose_name=_('Vendor Entity'),
-                                     editable=False)
+    entity_model = models.ForeignKey(
+        'django_ledger.EntityModel',
+        on_delete=models.CASCADE,
+        verbose_name=_('Vendor Entity'),
+        editable=False,
+    )
     description = models.TextField()
     active = models.BooleanField(default=True)
     hidden = models.BooleanField(default=False)
-    picture = models.ImageField(upload_to=vendor_picture_upload_to, null=True, blank=True)
+    picture = models.ImageField(
+        upload_to=vendor_picture_upload_to, null=True, blank=True
+    )
 
     additional_info = models.JSONField(null=True, blank=True, default=dict)
 
@@ -219,9 +261,7 @@ class VendorModelAbstract(ContactInfoMixIn,
             models.Index(fields=['active']),
             models.Index(fields=['hidden']),
         ]
-        unique_together = [
-            ('entity_model', 'vendor_number')
-        ]
+        unique_together = [('entity_model', 'vendor_number')]
         abstract = True
 
     def __str__(self):
@@ -229,6 +269,20 @@ class VendorModelAbstract(ContactInfoMixIn,
             f'Unknown Vendor: {self.vendor_name}'
         return f'{self.vendor_number}: {self.vendor_name}'
 
+    def validate_for_entity(self, entity_model: 'EntityModel | str | UUID'):
+        EntityModel = lazy_loader.get_entity_model()
+        if isinstance(entity_model, str):
+            is_valid = entity_model == self.entity_model.slug
+        elif isinstance(entity_model, EntityModel):
+            is_valid = entity_model == self.entity_model
+        elif isinstance(entity_model, UUID):
+            is_valid = entity_model == self.entity_model_id
+
+        if not is_valid:
+            raise VendorModelValidationError(
+                'EntityModel does not belong to this Vendor'
+            )
+
     def can_generate_vendor_number(self) -> bool:
         """
         Determines if the VendorModel can be issued a Vendor Number.
@@ -239,10 +293,7 @@ class VendorModelAbstract(ContactInfoMixIn,
         bool
             True if the vendor number can be generated, else False.
         """
-        return all([
-            self.entity_model_id,
-            not self.vendor_number
-        ])
+        return all([self.entity_model_id, not self.vendor_number])
 
     def _get_next_state_model(self, raise_exception: bool = True):
         """
@@ -264,10 +315,12 @@ class VendorModelAbstract(ContactInfoMixIn,
         try:
             LOOKUP = {
                 'entity_model_id__exact': self.entity_model_id,
-                'key__exact': EntityStateModel.KEY_VENDOR
+                'key__exact': EntityStateModel.KEY_VENDOR,
             }
 
-            state_model_qs = EntityStateModel.objects.filter(**LOOKUP).select_for_update()
+            state_model_qs = EntityStateModel.objects.filter(
+                **LOOKUP
+            ).select_for_update()
             state_model = state_model_qs.get()
             state_model.sequence = F('sequence') + 1
             state_model.save()
@@ -275,13 +328,12 @@ class VendorModelAbstract(ContactInfoMixIn,
 
             return state_model
         except ObjectDoesNotExist:
-
             LOOKUP = {
                 'entity_model_id': self.entity_model_id,
                 'entity_unit_id': None,
                 'fiscal_year': None,
                 'key': EntityStateModel.KEY_VENDOR,
-                'sequence': 1
+                'sequence': 1,
             }
             state_model = EntityStateModel.objects.create(**LOOKUP)
             return state_model
@@ -306,7 +358,6 @@ class VendorModelAbstract(ContactInfoMixIn,
         """
         if self.can_generate_vendor_number():
             with transaction.atomic(durable=True):
-
                 state_model = None
                 while not state_model:
                     state_model = self._get_next_state_model(raise_exception=False)

django_ledger/report/core.py

@@ -6,25 +6,16 @@ from django.core.exceptions import ValidationError
 from django_ledger.io.io_context import IODigestContextManager
 from django_ledger.models.ledger import LedgerModel
 from django_ledger.models.unit import EntityUnitModel
-from django_ledger.settings import DJANGO_LEDGER_PDF_SUPPORT_ENABLED
 from django_ledger.templatetags.django_ledger import currency_symbol, currency_format
 
-if DJANGO_LEDGER_PDF_SUPPORT_ENABLED:
-    from fpdf import FPDF, XPos, YPos
+from fpdf import FPDF, XPos, YPos
 
 
 class PDFReportValidationError(ValidationError):
     pass
 
 
-def load_support():
-    support = list()
-    if DJANGO_LEDGER_PDF_SUPPORT_ENABLED:
-        support.append(FPDF)
-    return support
-
-
-class BaseReportSupport(*load_support()):
+class BaseReportSupport(FPDF):
     FOOTER_LOGO_PATH = 'django_ledger/logo/django-ledger-logo-report.png'
 
     def __init__(self,
@@ -33,9 +24,6 @@ class BaseReportSupport(*load_support()):
                  report_subtitle: Optional[str] = None,
                  **kwargs):
 
-        if not DJANGO_LEDGER_PDF_SUPPORT_ENABLED:
-            raise NotImplementedError('PDF support not enabled.')
-
         super().__init__(*args, **kwargs)
         self.REPORT_TYPE: Optional[str] = None
         self.REPORT_SUBTITLE: Optional[str] = report_subtitle