AceFire6 / ordered-arrowverse

A listing of all shows in the Arrowverse in watch order to ensure continuity and sensible ordering for crossover episodes
https://arrowverse.info
102 stars 33 forks source link

Update tortoise-orm to 0.16.13 #268

Closed pyup-bot closed 4 years ago

pyup-bot commented 4 years ago

This PR updates tortoise-orm from 0.13.2 to 0.16.13.

Changelog ### 0.16.13 ``` ------- - Default install of ``tortoise-orm`` now installs with no C-dependencies, if you want to use the C accelerators, please do a ``pip install tortoise-orm[accel]`` instead. - Added ``<instance>.clone()`` method that will create a cloned instance in memory. To persist it you still need to call ``.save()`` - ``.clone()`` will raise a ``ParamsError`` if tortoise can't generate a primary key. In that case do a ``.clone(pk=<newval>)`` - If manually setting the primary key value to ``None`` and the primary key can be automatically generated, this will create a new record. We however still recommend the ``.clone()`` method instead. - ``.save()`` can be forced to do a create by setting ``force_create=True`` - ``.save()`` can be forced to do an update by setting ``force_update=True`` - Setting ``update_fields`` for a ``.save()`` operation will strongly prefer to do an update if possible ``` ### 0.16.12 ``` ------- - Make ``Field.default`` effect on db level when generate table - Add converters instead of importing from pymysql - Fix postgres BooleanField default value convent - Fix ``JSONField`` typed in ``pydantic_model_creator`` - Add ``.sql()`` method on ``QuerySet`` ``` ### 0.16.11 ``` ------- - fix: ``sqlite://:memory:`` in Windows thrown ``OSError: [WinError 123]`` - Support ``bulk_create()`` insertion of records with overridden primary key when the primary key is DB-generated - Add ``queryset.exists()`` and ``Model.exists()``. - Add model subscription lookup, ``Model[<pkval>]`` that will return the object or raise ``KeyError`` ``` ### 0.16.10 ``` ------- - Fix bad import of ``basestring`` - Better handling of NULL characters in strings. Fixes SQLite, raises better error for PostgreSQL. - Support ``.group_by()`` with join now ``` ### 0.16.9 ``` ------ - Support ``F`` expression in ``.save()`` now - ``IntEnumField`` accept valid int value and ``CharEnumField`` accept valid str value - Pydantic models get created with globally unique identifier - Leaf-detection to minimize duplicate Pydantic model creation - Pydantic models with a Primary Key that is also a raw field of a relation is now not hidden when ``exclude_raw_fields=True`` as it is a critically important field - Raise an informative error when a field is set as nullable and primary key at the same time - Foreign key id's are now described to have the positive-integer range of the field it is related to - Fixed prefetching over OneToOne relations - Fixed ``__contains`` for non-text fields (e.g. ``JSONB``) ``` ### 0.16.8 ``` ------ - Allow ``Q`` expression to function with ``_filter`` parameter on aggregations - Add manual ``.group_by()`` support - Fixed regression where ``GROUP BY`` class is missing for an aggregate with a specified order. ``` ### 0.16.7 ``` ------ - Added preliminary support for Python 3.9 - ``TruncationTestCase`` now properly quotes table names when it clears them out. - Add model signals support - Added ``app_label`` to ``test initializer(...)`` and ``TORTOISE_TEST_APP`` as test environment variable. ``` ### 0.16.6 ``` ------ .. warning:: This is a security fix release. We recommend everyone update. Security fixes ^^^^^^^^^^^^^^ - Fixed SQL injection issue in MySQL - Fixed SQL injection issues in MySQL when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) - Fixed malformed SQL for PostgreSQL and SQLite when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) Other changes ^^^^^^^^^^^^^ * Added support for partial models: To create a partial model, one can do a ``.only(<fieldnames-as-strings>)`` as part of the QuerySet. This will create model instances that only have those values fetched. Persisting changes on the model is allowed only when: * All the fields you want to update is specified in ``<model>.save(update_fields=[...])`` * You included the Model primary key in the ``.only(...)`` To protect against common mistakes we ensure that errors get raised: * If you access a field that is not specified, you will get an ``AttributeError``. * If you do a ``<model>.save()`` a ``IncompleteInstanceError`` will be raised as the model is, as requested, incomplete. * If you do a ``<model>.save(update_fields=[...])`` and you didn't include the primary key in the ``.only(...)``, then ``IncompleteInstanceError`` will be raised indicating that updates can't be done without the primary key being known. * If you do a ``<model>.save(update_fields=[...])`` and one of the fields in ``update_fields`` was not in the ``.only(...)``, then ``IncompleteInstanceError`` as that field is not available to be updated. - Fixed bad SQL generation when doing a ``.values()`` query over a Foreign Key - Added `<model>.update_from_dict({...})` that will mass update values safely from a dictionary - Fixed processing URL encoded password in connection string ``` ### 0.16.5 ``` ------ * Moved ``Tortoise.describe_model(<MODEL>, ...)`` to ``<MODEL>.describe(...)`` * Deprecated ``Tortoise.describe_model()`` * Fix for ``generate_schemas`` param being ignored in ``tortoise.contrib.quart.register_tortoise`` * Fix join query with `source_field` param ``` ### 0.16.4 ``` ------ * More consistent escaping of db columns, fixes using SQL reserved keywords as field names with a function. * Fix the aggregates using the wrong side of the join when doing a self-referential aggregation. * Fix ``F`` funtions wrapped forgetting about ``distinct=True`` ``` ### 0.16.3 ``` ------ * Fixed invalid ``var IN ()`` SQL generated using ``__in=`` and ``__not_in`` filters. * Fix bug with order_by on nested fields * Fix joining with self by reverse-foreign-key for filtering and annotation ``` ### 0.16.2 ``` ------ * Default ``values()`` & ``values_list()`` now includes annotations. * Annotations over joins now work correctly with ``values()`` & ``values_list()`` * Ensure ``GROUP BY`` precedes ``HAVING`` to ensure that filtering by aggregates work correctly. * Fix bug with join query with aggregation * Cast ``BooleanField`` values correctly on SQLite & MySQL ``` ### 0.16.1 ``` ------ * ``QuerySetSingle`` now has better code completion * Created Pydantic models will now have the basic validation elements: * ``required`` is correctly populated for required fields * ``nullable`` is added to the schema where nulls are accepted * ``maxLength`` for CharFields * ``minimum`` & ``maximum`` values for integer fields To get Pydantic to handle nullable/default fields correctly one should do a ``**user.dict(exclude_unset=True)`` when passing values to a Model class. * Added ``FastAPI`` helper that is based on the ``starlette`` helper but optionally adds helpers to catch and report with proper error ``DoesNotExist`` and ``IntegrityError`` Tortoise exceptions. * Allows a Pydantic model to exclude all read-only fields by setting ``exclude_readonly=True`` when calling ``pydantic_model_creator``. * a Tortoise ``PydanticModel`` now provides two extra helper functions: * ``from_queryset``: Returns a ``List[PydanticModel]`` which is the format that e.g. FastAPI expects * ``from_queryset_single``: allows one to avoid calling ``await`` multiple times to get the object and all its related items. ``` ### 0.16 ``` ==== ``` ### 0.16.0 ``` ------ .. caution:: **This release drops support for Python 3.6:** Tortoise ORM now requires a minimum of CPython 3.7 New features: ^^^^^^^^^^^^^ * Model docstrings and ``:`` comments directly preceding Field definitions are now used as docstrings and DDL descriptions. This is now cleaned and carried as part of the ``docstring`` parameter in ``describe_model(...)`` If one doesn't explicitly specify a Field ``description=`` or Model ``Meta.table_description=`` then we default to the first line as the description. This is done because a description is submitted to the DB, and needs to be short (depending on DB, 63 chars) in size. Usage example: .. code-block:: python3 class Something(Model): """ A Docstring. Some extra info. """ A regular comment name = fields.CharField(max_length=50) : A docstring comment chars = fields.CharField(max_length=50, description="Some chars") : A docstring comment : Some more detail blip = fields.CharField(max_length=50) When looking at the describe model: { "description": "A Docstring.", "docstring": "A Docstring.\n\nSome extra info.", ... "data_fields": [ { "name": "name", ... "description": null, "docstring": null }, { "name": "chars", ... "description": "Some chars", "docstring": "A docstring comment" }, { "name": "blip", ... "description": "A docstring comment", "docstring": "A docstring comment\nSome more detail" } ] } * Early Partial Init of models. We now have an early init of models, which can be useful when needing Models that are not bound to a DB, but otherwise complete. e.g. Schema generation without needing to be properly set up. Usage example: .. code-block:: python3 Lets say you defined your models in "some/models.py", and "other/ddef.py" And you are going to use them in the "model" namespace: Tortoise.init_models(["some.models", "other.ddef"], "models") Now the models will have relationships built, so introspection of schema will be comprehensive * Pydantic serialisation. We now include native support for automatically building a Pydantic model from Tortoise ORM models. This will correctly model: * Data Fields * Relationships (FK/O2O/M2M) * Callables At this stage we only suport serialisation, not deserialisation. For mode information, please see :ref:`contrib_pydantic` - Allow usage of ``F`` expressions to in annotations. (301) - Now negative number with ``limit(...)`` and ``offset(...)`` raise ``ParamsError``. (306) - Allow usage of Function to ``queryset.update()``. (308) - Add ability to supply ``distinct`` flag to Aggregate (312) Bugfixes: ^^^^^^^^^ - Fix default type of ``JSONField`` Removals: ^^^^^^^^^ - Removed ``tortoise.aggregation`` as this was deprecated since 0.14.0 - Removed ``start_transaction`` as it has been broken since 0.15.0 - Removed support for Python 3.6 / PyPy-3.6, as it has been broken since 0.15.0 If you still need Python 3.6 support, you can install ``tortoise-orm<0.16`` as we will still backport critical bugfixes to the 0.15 branch for a while. .. rst-class:: emphasize-children ``` ### 0.15.24 ``` ------- - Fixed regression where ``GROUP BY`` class is missing for an aggregate with a specified order. ``` ### 0.15.23 ``` ------- - Fixed SQL injection issue in MySQL - Fixed SQL injection issues in MySQL when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) - Fixed malformed SQL for PostgreSQL and SQLite when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) ``` ### 0.15.22 ``` ------- * Fix the aggregates using the wrong side of the join when doing a self-referential aggregation. * Fix for ``generate_schemas`` param being ignored in ``tortoise.contrib.quart.register_tortoise`` ``` ### 0.15.21 ``` ------- * Fixed invalid ``var IN ()`` SQL generated using ``__in=`` and ``__not_in`` filters. * Fix bug with order_by on nested fields * Fix joining with self by reverse-foreign-key for filtering and annotation ``` ### 0.15.20 ``` ------- * Default ``values()`` & ``values_list()`` now includes annotations. * Annotations over joins now work correctly with ``values()`` & ``values_list()`` * Ensure ``GROUP BY`` precedes ``HAVING`` to ensure that filtering by aggregates work correctly. * Cast ``BooleanField`` values correctly on SQLite & MySQL ``` ### 0.15.19 ``` ------- - Fix Function with ``source_field`` option. (311) ``` ### 0.15.18 ``` ------- - Install on Windows does not require a C compiler any more. - Fix ``IntegrityError`` with unique field and ``get_or_create`` ``` ### 0.15.17 ``` ------- - Now ``get_or_none(...)``, classmethod of ``Model`` class, works in the same way as ``queryset`` ``` ### 0.15.16 ``` ------- - ``get_or_none(...)`` now raises ``MultipleObjectsReturned`` if multiple object fetched. (298) ``` ### 0.15.15 ``` ------- - Add ability to suppply a ``to_field=`` parameter for FK/O2O to a non-PK but still uniquely indexed remote field. (287) ``` ### 0.15.14 ``` ------- - add F expression support in ``queryset.update()`` - This allows for atomic updates of data in the database. (294) ``` ### 0.15.13 ``` ------- - Applies default ordering on related queries - Fix post-ManyToMany related queries not being evaluated correctly - Ordering is now preserved on ManyToMany related fetches - Fix aggregate function on joined table to use correct primary key - Fix filtering by backwards FK to use correct primary key ``` ### 0.15.12 ``` ------- - Added ``range`` filter to support ``between and`` syntax ``` ### 0.15.11 ``` ------- - Added ``ordering`` option for model ``Meta`` class to apply default ordering ``` ### 0.15.10 ``` ------- - Bumped requirements to cater for newer feature use (282) ``` ### 0.15.9 ``` ------ - Alias Foreign Key joins as we can have both self-referencing and duplicate joins to the same table. This generates SQL that differentiates between which instance of the table to work with. ``` ### 0.15.8 ``` ------ - ``TextField`` now recommends usage of ``CharField`` if wanting unique indexing instead of just saying "indexing not supported" - ``.count()`` now honours offset and limit - Testing un-awaited ``ForeignKeyField`` as a boolean expression will automatically resolve as ``False`` if it is None - Awaiting a nullable ``ForeignKeyField`` won't touch the DB if it is ``None`` ``` ### 0.15.7 ``` ------ - ``QuerySet.Update()`` now returns the count of the no of rows affected. Note, that - ``QuerySet.Delete()`` now returns the count of the no of rows deleted. - Note that internal API of ``db_connection.execute_query()`` now returns ``rows_affected, results``. (This is informational only) - Added ``get_or_none(...)`` as syntactic sugar for ``filter(...).first()`` ``` ### 0.15.6 ``` ------ - Added ``BinaryField`` for storing binary objects (``bytes``). - Changed ``TextField`` to use ``LONGTEXT`` for MySQL to allow for larger than 64KB of text. - De-duplicate index if specified on both ``index=true`` and as part of ``indexes`` - Primary Keyed ``TextField`` is marked as deprecated. We can't guarnatee that it will be properly indexed or unique in all cases. - One can now disable the backwards relation for FK/O2O relations by passing ``related_name=False`` - One can now pass a PK value to a generated field, and Tortoise ORM will use that as the PK as expected. This allows one to have a model that has a autonumber PK, but setting it explicitly if required. ``` ### 0.15.5 ``` ------ * Refactored Fields: Fields have been refactored, for better maintenance. There should be no change for most users. - More accurate auto-completion. - Fields now contain their own SQL schema by dialect, which significantly simplifies adding field types. - ``describe_model()`` now returns the DB type, and dialect overrides. - ``JSONField`` will now automatically use ``python-rapidjson`` as an accelerator if it is available. - ``DecimalField`` and aggregations on it, now behaves much more like expected on SQLite (256) - Check whether charset name is valid for the MySQL connection (261) - Default DB driver parameters are now applied consistently, if you use the URI schema or manual. ``` ### 0.15.4 ``` ------ - Don't generate a schema if there is no models (254) - Emit a ``RuntimeWarning`` when a module has no models to import (254) - Allow passing in a custom SSL context (255) ``` ### 0.15.3 ``` ------ * Added ``OneToOneField`` implementation: ``OneToOneField`` describes a one to one relation between two models. It can be set from the primary side only, but resolved from both sides in the same way. ``describe_model(...)`` now also reports OneToOne relations in both directions. Usage example: .. code-block:: python3 event: fields.OneToOneRelation[Event] = fields.OneToOneField( "models.Event", on_delete=fields.CASCADE, related_name="address" ) - Prefetching is done concurrently now, sending all prefetch requests at the same time instead of in sequence. - Enabe foreign key enforcement on SQLite for builds where it was optional. ``` ### 0.15.2 ``` ------ - The ``auto_now_add`` argument of ``DatetimeField`` is handled correctly in the SQLite backend. - ``unique_together`` now creates named constrains, to prevent the DB from auto-assigning a potentially non-unique constraint name. - Filtering by an ``auto_now`` field doesn't replace the filter value with ``now()`` anymore. ``` ### 0.15.1 ``` ------ - Handle OR'ing a blank ``Q()`` correctly (240) ``` ### 0.15 ``` ==== ``` ### 0.15.0 ``` ------- New features: ^^^^^^^^^^^^^ - Pooling has been implemented, allowing for multiple concurrent databases and all the benefits that comes with it. - Enabled by default for databases that support it (mysql and postgres) with a minimum pool size of 1, and a maximum of 5 - Not supported by sqlite - Can be changed by passing the ``minsize`` and ``maxsize`` connection parameters - Many small performance tweaks: - Overhead of query generation has been reduced by about 6% - Bulk inserts are ensured to be wrapped in a transaction for >50% speedup - PostgreSQL prepared queries now use a LRU cache for significant >2x speedup on inserts/updates/deletes - ``DateField`` & ``DatetimeField`` deserializes faster on PostgreSQL & MySQL. - Optimized ``.values()`` to do less copying, resulting in a slight speedup. - One can now pass kwargs and ``Q()`` objects as parameters to ``Q()`` objects simultaneously. Bugfixes: ^^^^^^^^^ - ``indexes`` will correctly map the foreign key if referenced by name. - Setting DB generated PK in constructor/create generates exception instead of silently being ignored. Deprecations: ^^^^^^^^^^^^^ - ``start_transaction`` is deprecated, please use ``atomic()`` or ``async with in_transaction():`` instead. - **This release brings with it, deprecation of Python 3.6 / PyPy-3.6:** This is due to small differences with how the backported ``aiocontextvars`` behaves in comparison to the built-in in Python 3.7+. There is a known context confusion, specifically regarding nested transactions. .. rst-class:: emphasize-children ``` ### 0.14.2 ``` ------ - A Field name of ``alias`` is now no longer reserved. - Restored support for inheriting from Abstract classes. Order is now also deterministic, with the inherited classes' fields being placed before the current. ``` ### 0.14.1 ``` ------- - ``ManyToManyField`` is now a function that has the type of the relation for autocomplete, this allows for better type hinting at less effort. - Added section on adding better autocomplete for relations in editors. ``` ### 0.14 ``` ==== ``` ### 0.14.0 ``` ------ .. caution:: **This release drops support of Python 3.5:** Tortoise ORM now requires a minimum of CPython 3.6 or PyPy3.6-7.1 Enhancements: ^^^^^^^^^^^^^ - Models, Fields & QuerySets have significant type annotation improvements, leading to better IDE integration and more comprehensive static analysis. - Fetching records from the DB is now up to 25% faster. - Database functions ``Trim()``, ``Length()``, ``Coalesce()``, ``Lower()``, ``Upper()`` added to tortoise.functions module. - Annotations can be selected inside ``Queryset.values()`` and ``Queryset.values_list()`` expressions. - Added support for Python 3.8 - The Foreign Key property is now ``await``-able as long as one didn't populate it via ``.prefetch_related()`` - One can now specify compound indexes in the ``Meta:`` class using ``indexes``. It works just like ``unique_toghether``. Bugfixes: ^^^^^^^^^ - The generated index name now has significantly lower chance of collision. - The compiled SQL query contains HAVING and GROUP BY only for aggregation functions. - Fields for FK relations are quoted properly. - Fields are quoted properly in ``UNIQUE`` statements. - Fields are quoted properly in ``KEY`` statements. - Comment Fields are quoted properly in PostgreSQL dialect. - ``unique_together`` will correctly map the foreign key if referenced by name. Deprecations: ^^^^^^^^^^^^^ - ``import from tortoise.aggregation`` is deprecated, please do ``import from tortoise.functions`` instead. Breaking Changes: ^^^^^^^^^^^^^^^^^ - The hash used to make generated indexes unique has changed. The old algorithm had a very high chance of collisions, the new hash algorithm is much better in this regard. - Dropped support for Python 3.5 .. rst-class:: emphasize-children ``` ### 0.13.12 ``` ------- - Reverted "The ``Field`` class now calls ``super().__init__``, so mixins are properly initialised." as it was causing issues on Python 3.6. ``` ### 0.13.11 ``` ------- - Fixed the ``_FieldMeta`` class not to checking if the 1st base class was Field, so would break with mixins. - The ``Field`` class now calls ``super().__init__``, so mixins are properly initialised. ``` ### 0.13.10 ``` ------- - Names ForeignKey constraints in a consistent way ``` ### 0.13.9 ``` ------ - Fields can have 2nd base class which makes IDEs know python type (str, int, datetime...) of the field. - The ``type`` parameter of ``Field.__init__`` is removed, instead we use the 2nd base class - Foreign keys and indexes are now defined correctly in MySQL so that they take effect as expected - MySQL now doesn't warn of unsafe index creation anymore ``` ### 0.13.8 ``` ------ - Fixed bug in schema creation for MySQL where non-int PK did not get declared properly (195) ``` ### 0.13.7 ``` ------ - ``iexact`` filter modifier was implemented. Queries like ``«queryset».filter(name__iexact=...)`` will perform case-insensitive search. ``` ### 0.13.6 ``` ------ - Fix minor bug in ``Model.__init__`` where we raise the wrong error on setting RFK/M2M values directly. - Fields in ``Queryset.values_list()`` is now in the defined Model order. - Fields in ``Queryset.values()`` is now in the defined Model order. ``` ### 0.13.5 ``` ------ - Sample Starlette integration - Relational fields are now lazily constructed via properties instead of in the constructor, this results in a significant overhead reduction for Model instantiation with many relationships. ``` ### 0.13.4 ``` ------ - Assigning to the FK field will correctly set the associated db-field - Reading a nullalble FK field can now be None - Nullalble FK fields reverse-FK is now also nullable - Deleting a nullable FK field sets it to None ``` ### 0.13.3 ``` ------ - Fixed installing Tortoise-ORM in non-unicode systems. (180) - ``«queryset».update(…)`` now correctly uses the DB-specific ``to_db_value()`` - ``fetch_related(…)`` now correctly encodes non-integer keys. - ``ForeignKey`` fields of type ``UUIDField`` are now escaped consistently. - Pre-generated ForeignKey fields (e.g. UUIDField) is now checked for persistence correctly. - Duplicate M2M ``.add(…)`` now checks using consistent field encoding. - ``source_field`` Fields are now handled correctly for ordering. - ``source_field`` Fields are now handled correctly for updating. ```
Links - PyPI: https://pypi.org/project/tortoise-orm - Changelog: https://pyup.io/changelogs/tortoise-orm/ - Repo: https://github.com/tortoise/tortoise-orm