Metadata-Version: 1.2
Name: django-queryable-properties
Version: 1.4.0
Summary: Write Django model properties that can be used in database queries.
Home-page: https://github.com/W1ldPo1nter/django-queryable-properties
Author: Marcus Klöpfel
Author-email: marcus.kloepfel@gmail.com
Maintainer: Marcus Klöpfel
Maintainer-email: marcus.kloepfel@gmail.com
License: BSD
Description: ===========================
        django-queryable-properties
        ===========================
        
        .. image:: https://travis-ci.com/W1ldPo1nter/django-queryable-properties.svg?branch=master
           :target: https://travis-ci.com/W1ldPo1nter/django-queryable-properties
        .. image:: https://codecov.io/gh/W1ldPo1nter/django-queryable-properties/branch/master/graph/badge.svg
           :target: https://codecov.io/gh/W1ldPo1nter/django-queryable-properties
        .. image:: https://readthedocs.org/projects/django-queryable-properties/badge/?version=latest
           :target: https://django-queryable-properties.readthedocs.io/en/latest/?badge=latest
        .. image:: https://img.shields.io/pypi/v/django-queryable-properties.svg
           :target: https://pypi.org/project/django-queryable-properties
        
        *django-queryable-properties* is a `Django`_ extension that allows to implement model properties which can be used
        in database queries performed via Django's ORM.
        
        .. _Django: https://www.djangoproject.com/
        
        Further information, including supported Python and Django versions as well as installation instructions, can be found
        in the `documentation hosted by readthedocs`_.
        
        .. _documentation hosted by readthedocs: https://django-queryable-properties.readthedocs.io/
        
        Contributing and getting help
        =============================
        
        The `GitHub repository`_ is the central place to report bugs and get help using the `GitHub issues`_ as well as to
        contribute to the project via pull requests while following the `guide on contributing`_.
        
        .. _GitHub repository: https://github.com/W1ldPo1nter/django-queryable-properties
        .. _GitHub issues: https://github.com/W1ldPo1nter/django-queryable-properties/issues
        .. _guide on contributing: https://github.com/W1ldPo1nter/django-queryable-properties/blob/master/CONTRIBUTING.rst
        
        
        Changelog
        =========
        
        master (unreleased)
        -------------------
        
        1.4.0 (2020-10-17)
        ------------------
        
        - ``ValueCheckProperty`` and ``RangeCheckProperty`` objects can now take more complex attribute paths instead of simple
          field/attribute names
        - ``RangeCheckProperty`` objects now have an option that determines how to treat missing values to support ranges with
          optional boundaries
        - Added a new ready-to-use queryable property implementation for properties based on simple aggregates
          (``AggregateProperty``)
        
        1.3.1 (2020-08-04)
        ------------------
        
        - Added support for Django 3.1
        - Refactored decorator-based properties to be more maintainable and memory-efficient and documented a way to use them
          without actually decorating
        
        1.3.0 (2020-05-22)
        ------------------
        
        - Added an option to implement simplified custom boolean filters utilizing lookup-based filters
        - Fixed the ability to use the ``classmethod`` or ``staticmethod`` decorators with lookup-based filter methods for
          decorator-based properties
        - Fixed the queryable property resolution in ``When`` parts of conditional updates
        - Fixed the ability to use conditional expressions directly in ``.filter``/``.exclude`` calls in Django 3.0
        
        1.2.1 (2019-12-03)
        ------------------
        
        - Added support for Django 3.0
        
        1.2.0 (2019-10-21)
        ------------------
        
        - Added a mixin that allows custom filters for queryable properties (both class- and decorator-based) to be implemented
          using multiple functions/methods for different lookups
        - Added some ready-to-use queryable property implementations (``ValueCheckProperty``, ``RangeCheckProperty``) to
          simplify common code patterns
        - Added a standalone version of six to the package requirements
        
        1.1.0 (2019-06-23)
        ------------------
        
        - Queryable property filters (both annotation-based and custom) can now be used across relations when filtering
          querysets (i.e. a queryset can now be filtered by a queryable property on a related model)
        - Queryset annotations can now refer to annotatable queryable properties defined on a related model
        - Querysets can now be ordered by annotatable queryable properties defined on a related model
        - Filters and annotations that reference annotatable queryable properties will not select the queryable property
          annotation anymore in Django versions below 1.8 (ordering by such a property will still lead to a selection in these
          versions)
        - Fixed unnecessary selections of queryable property annotations in querysets that don't return model instances (i.e.
          queries with ``.values()`` or ``.values_list()``)
        - Fixed unnecessary fields in ``GROUP BY`` clauses in querysets that don't return model instances (i.e. queries with
          ``.values()`` or ``.values_list()``) in Django versions below 1.8
        - Fixed an infinite recursion when constructing the ``HAVING`` clause for annotation-based filters that are not an
          aggregate in Django 1.8
        
        1.0.2 (2019-06-02)
        ------------------
        
        - The ``lookup`` parameter of custom filter implementations of queryable properties will now receive the combined
          lookup string if multiple lookups/transforms are used at once instead of just the first lookup/transform
        - Fixed the construction of ``GROUP BY`` clauses when annotating queryable properties based on aggregates
        - Fixed the construction of ``HAVING`` clauses when annotating queryable properties based on aggregates in Django
          versions below 1.9
        - Fixed the ability to pickle queries and querysets with queryable properties functionality in Django versions below
          1.6
        
        1.0.1 (2019-05-11)
        ------------------
        
        - Added support for Django 2.2
        
        1.0.0 (2018-12-31)
        ------------------
        
        - Initial release
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Web Environment
Classifier: Framework :: Django
Classifier: Framework :: Django :: 1.4
Classifier: Framework :: Django :: 1.5
Classifier: Framework :: Django :: 1.6
Classifier: Framework :: Django :: 1.7
Classifier: Framework :: Django :: 1.8
Classifier: Framework :: Django :: 1.9
Classifier: Framework :: Django :: 1.10
Classifier: Framework :: Django :: 1.11
Classifier: Framework :: Django :: 2.0
Classifier: Framework :: Django :: 2.1
Classifier: Framework :: Django :: 2.2
Classifier: Framework :: Django :: 3.0
Classifier: Framework :: Django :: 3.1
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Topic :: Internet
