fallback-property 0.1.0

Requirements

• Python 3.6

What is it?

fallback_property transforms a function into a property and uses the decorated function as fallback if no value was assigned to the property itself. A special descriptor (fallback_property.FallbackDescriptor) is used internally.

How to use it?

Simply define a function and use the decorator fallback_property

from fallback_property import fallback_property

class Foo:

    @fallback_property()
    def fallback_func(self):
        return 7

Usage Example (Django)

Suppose we have the following models

from django.db import models


class Pipeline(model.Model):
    @property
    def total_length(self):
        return sum(self.parts.values_list('length', flat=True))


class Parts(models.Model):
    length = models.PositiveIntegerField()
    pipeline = models.ForeignKey(Pipeline, related_name='parts')

Calling pipline.total_length will always trigger another query and is even more expensive when dealing with multiple objects. This can be optimized by using .annotate() and fallback_property()

from django.db import models, QuerySet
from django.db.functions import Coalesce
from django.db.models import Sum
from fallback_property import fallback_property


class PipelineQuerySet(QuerySet):

    def with_total_length(self):
        return self.annotate(
            total_length=Coalesce(
                Sum('parts__length', output_field=models.IntegerField()),
                0,
            )
        )


class Pipeline(model.Model):

    @fallback_property(logging=True)
    def total_length(self):
        return sum(self.parts.values_list('length', flat=True))

You can now access the total_length without triggering another query or get a warning, when the fallback function is used

pipeline = Pipeline.objects.with_total_length().first()
print(pipeline.total_length)

Important: The annotated value and the property must have the same name.

from django.db import models, QuerySet
from django.db.functions import Coalesce
from django.db.models import F
from fallback_property import fallback_property


class PartQuerySet(QuerySet):

    def with_owner(self):
        return self.annotate(
            owner=Coalesce(
                F('_owner'),
                F('pipeline__owner'),
                None,
            )
        )


class Pipeline(model.Model):
    owner = models.ForeignKey(User)


class Parts(models.Model):
    _owner = models.ForeignKey(User, blank=True, null=True, on_delete=models.SET_NULL)
    length = models.PositiveIntegerField()
    pipeline = models.ForeignKey(Pipeline, related_name='parts')

    objects = PartQuerySet()

    @fallback_property()
    def owner(self):
        return self._owner or self.pipline.owner


>>> print(Part.objects.with_owner().first().owner)
>>> 1

Development

This project is using poetry to manage all dev dependencies.

Clone this repository and run

poetry develop
poetry run pip install django

to create a virtual environment with all dependencies.

You can now run the test suite using

poetry run pytest

This repository follows the angular commit conventions. You can register a pre-commit hook to validate your commit messages by using husky. The configurations are already in place if you have nodejs installed. Just run

npm install

and the pre-commit hook will be registered.