Metadata-Version: 2.1
Name: django-computedfields
Version: 0.1.7
Summary: autoupdated database fields for model methods
Home-page: https://github.com/netzkolchose/django-computedfields
Author: netzkolchose
Author-email: j.breitbart@netzkolchose.de
License: MIT
Download-URL: https://github.com/netzkolchose/django-computedfields/archive/0.1.7.tar.gz
Description: [![build](https://github.com/netzkolchose/django-computedfields/actions/workflows/build.yml/badge.svg)](https://github.com/netzkolchose/django-computedfields/actions/workflows/build.yml)
        [![Coverage Status](https://coveralls.io/repos/github/netzkolchose/django-computedfields/badge.svg?branch=master)](https://coveralls.io/github/netzkolchose/django-computedfields?branch=master)
        
        
        ### django-computedfields ###
        
        django-computedfields provides autoupdated database fields
        for model methods.
        
        Tested with Django 3.2 and 4.0 (Python 3.7 to 3.10).
        
        
        #### Example ####
        
        Just derive your model from `ComputedFieldsModel` and place
        the `@computed` decorator at a method:
        
        ```python
        from django.db import models
        from computedfields.models import ComputedFieldsModel, computed
        
        class MyModel(ComputedFieldsModel):
            name = models.CharField(max_length=32)
        
            @computed(models.CharField(max_length=32), depends=[['self', ['name']]])
            def computed_field(self):
                return self.name.upper()
        ```
        
        `computed_field` will be turned into a real database field
        and can be accessed and searched like any other database field.
        During saving the associated method gets called and it’s result
        written to the database. 
        
        
        #### How to recalculate without saving the model record ####
        
        If you need to recalculate the computed field but without saving it, use
        `from computedfields.models import compute`
        
        ```python
        >>> from computedfields.models import compute
        >>> person = MyModel.objects.get(id=1)  # this is to retrieve existing record
        >>> person.computed_field               # outputs 'BERTY'
        >>> person.name = 'nina'                # changing the dependent field `name` to nina
        >>> compute(person, 'computed_field')   # outputs 'NINA'
        >>> person.computed_field               # outputs 'BERTY' because the `person` is not yet saved
        >>> person.save()                       # the save will now alter the database record for `name` and `computed_field`
        >>> person.computed_field               # outputs 'NINA'
        ```
        
        #### `depends` keyword
        
        The  `depends` keyword argument can be used with any relation to indicate dependencies to fields on other models as well:
        
        ```python
        from django.db import models
        from computedfields.models import ComputedFieldsModel, computed
        
        class MyModel(ComputedFieldsModel):
            name = models.CharField(max_length=32)
            fk = models.ForeignKey(SomeModel)
        
            @computed(models.CharField(max_length=32), depends=[['self', ['name']], ['fk', ['fieldname']]])
            def computed_field(self):
                return self.name.upper() + self.fk.fieldname
        ```
        
        Now changes to `self.name`, `fk` or `fk.fieldname` will update `computed_field`.
        
        
        #### Documentation ####
        
        The documentation can be found [here](https://django-computedfields.readthedocs.io/en/latest/index.html).
        
        
        #### Changelog ####
        
        - 0.1.7
            - add list type support for `update_fields` in signal handlers
        - 0.1.6
            - maintenace version with CI test dependencies changes:
                - removed Python 3.6
                - removed Django 2.2
                - added Python 3.10
                - added Django 4.0
                - move dev environment to Python 3.10 and Django 3.2
        
              Note that Django 2.2 will keep working until real incompatible code changes occur.
              This may happen by any later release, thus treat 0.1.6 as last compatible version.
        
        - 0.1.5
            - fix error on model instance cloning
        - 0.1.4
            - Django 3.2 support
        - 0.1.3
            - better multi table inheritance support and test cases
            - explicit docs for multi table inheritance
        - 0.1.2
            - bugfix: o2o reverse name access
            - add docs about model inheritance support
        - 0.1.1
            - bugfix: add missing migration
        - 0.1.0
            - fix recursion on empty queryset
            - dependency expansion on M2M fields
            - `m2m_changed` handler with filtering on m2m fields
            - remove custom metaclass, introducing *Resolver* class
            - new decorator `@precomputed` for custom save methods
            - old *depends* syntax removed
            - docs update
        - 0.0.23:
            - Bugfix: Fixing leaking computed fields in model inheritance.
        - 0.0.22:
            - Automatic dependency expansion on reverse relations.
            - Example documentation.
        - 0.0.21:
            - Bugfix: Fixing undefined _batchsize for pickled map usage.
        - 0.0.20
            - Use `bulk_update` for computed field updates.
            - Allow custom update optimizations with *select_related* and *prefetch_related*.
            - Respect computed field MRO in `compute`.
            - Allow updates on local computed fields from `update_dependent` simplifying bulk actions on `ComputedFieldsModel`.
        - 0.0.19
            - Better graph expansion on relation paths with support for *update_fields*.
        - 0.0.18
            - New *depends* syntax deprecating the old one.
            - MRO of local computed field methods implemented.
        - 0.0.17
            - Dropped Python 2.7 and Django 1.11 support.
        
Keywords: django,method,decorator,autoupdate,persistent,field
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Topic :: Database
Classifier: Topic :: Database :: Front-Ends
Classifier: Topic :: Software Development :: Libraries
Classifier: Framework :: Django
Classifier: Framework :: Django :: 3.2
Classifier: Framework :: Django :: 4.0
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Description-Content-Type: text/markdown
