Crudfastapi

Latest version: v0.1.2

Safety actively analyzes 681812 Python packages for vulnerabilities to keep your Python projects secure.

Scan your dependencies

Page 1 of 3

0.12.1

Added
- Deprecation Warning for dependency handling.

Detailed Changes
If you pass a sequence of `params.Depends` type variables to any `*_deps` parameter in `EndpointCreator` and `crud_router`, you'll get a warning. Support will be completely removed in 0.15.0.

**Full Changelog**: https://github.com/mithun2003/CRUDFastAPI/compare/v0.12.0...v0.12.1

0.12.0

Added
- Unpaginated versions of multi-row get methods by slaarti in 62 🎉
- Nested Join bug fixes
- Dependency handling now working as docs say
- Option to Skip commit in some CRUDFastAPI methods
- Docstring example fixes
- `__in` and `__not_in` filters by JakNowy 🎉
- Fastapi 0.111.0 support

Detailed Changes
Unpaginated versions of multi-row get methods
Now, if you pass `None` to `limit` in `get_multi` and `get_multi_joined`, you get the whole unpaginated set of data that matches the filters. Use this with caution.

python
from CRUDFastAPI import CRUDFastAPI
from .models.item import Item
from .database import session as db

crud_items = CRUDFastAPI(Item)
items = await crud_items.get_multi(db=db, limit=None)
this will return all items in the db


Dependency handling now working as docs say
Now, you may pass dependencies to `crud_router` or `EndpointCreator` as simple functions instead of needing to wrap them in `fastapi.Depends`.

python
from .dependencies import get_superuser
app.include_router(
crud_router(
session=db,
model=Item,
create_schema=ItemCreate,
update_schema=ItemUpdate,
delete_schema=ItemDelete,
create_deps=[get_superuser],
update_deps=[get_superuser],
delete_deps=[get_superuser],
path="/item",
tags=["item"],
)
)


Option to Skip commit in some CRUDFastAPI methods
For `create`, `update`, `db_delete` and `delete` methods of `CRUDFastAPI`, now you have the option of passing `commit=False` so you don't commit the operations immediately.

python
from CRUDFastAPI import CRUDFastAPI
from .models.item import Item
from .database import session as db

crud_items = CRUDFastAPI(Item)

await crud_items.delete(
db=db,
commit=False,
id=1
)
this will not actually delete until you run a db.commit()


`__in` and `__not_in` filters
You may now pass `__in` and `__not_in` to methods that accept advanced queries:

- `__gt`: greater than,
- `__lt`: less than,
- `__gte`: greater than or equal to,
- `__lte`: less than or equal to,
- `__ne`: not equal,
- `__in`: included in [tuple, list or set],
- `__not_in`: not included in [tuple, list or set],
- `__startswith`: starts with.

What's Changed
- Add unpaginated versions of multi-row get methods (w/tests) by [slaarti](https://github.com/slaarti) 🎉
- Join fixes
- Dependencies
- Skip commit
- Docstring fix
- feat: filter __in by [JakNowy](https://github.com/JakNowy) 🎉
- python support for 0.111.0 added
- version bump in pyproject.toml for 0.12.0

New Contributors
* [slaarti](https://github.com/slaarti) made their first contribution in https://github.com/mithun2003/CRUDFastAPI/pull/62 🎉

**Full Changelog**: https://github.com/mithun2003/CRUDFastAPI/compare/v0.11.1...v0.12.0

0.11.1

Added
- `one_or_none` parameter to CRUDFastAPI `get` method (default `False`)
- `nest_joins` parameter to CRUDFastAPI `get_joined` and `get_multi_joined` (default `False`)

Detailed Changes
`get`
By default, the `get` method in `CRUDFastAPI` returns the `first` object matching all the filters it finds.

If you want to ensure the `one_or_none` behavior, you may pass the parameter as `True`:

python
crud.get(
async_session,
one_or_none=True,
category_id=1
)


`get_joined` and `get_multi_joined`
By default, `CRUDFastAPI` joins all the data and returns it in a single dictionary.
Let's define two tables:
python
class User(Base):
__tablename__ = "user"
id = Column(Integer, primary_key=True)
name = Column(String)
tier_id = Column(Integer, ForeignKey("tier.id"))


class Tier(Base):
__tablename__ = "tier"
id = Column(Integer, primary_key=True)
name = Column(String, unique=True)


And join them with `CRUDFastAPI`:

python
user_tier = await user_crud.get_joined(
db=db,
model=Tier,
join_on=User.tier_id == Tier.id,
join_type="left",
join_prefix="tier_",,
id=1
)


We'll get:

javascript
{
"id": 1,
"name": "Example",
"tier_id": 1,
"tier_name": "Free",
}


Now, if you want the joined data in a nested dictionary instead, you may just pass `nest_joins=True`:

python
user_tier = await user_crud.get_joined(
db=db,
model=Tier,
join_on=User.tier_id == Tier.id,
join_type="left",
join_prefix="tier_",
nest_joins=True,
id=1,
)


And you will get:

javascript
{
"id": 1,
"name": "Example",
"tier": {
"id": 1,
"name": "Free",
},
}


This works for both `get_joined` and `get_multi_joined`.

!!! WARNING
Note that the final `"_"` in the passed `"tier_"` is stripped.

What's Changed
- Reuse of `select` method in `CRUDFastAPI`
- Skip count call when possible
- Add `one_or_none` parameter to CRUDFastAPI `get` method
- Add `nest_joins` parameter to CRUDFastAPI `get_joined` and `get_multi_joined`

New Contributors
- [JakNowy](https://github.com/JakNowy) made their first contribution in PR #51.

**Full Changelog**: [View the full changelog](https://github.com/mithun2003/CRUDFastAPI/compare/v0.11.0...v0.11.1)

0.11.0

Added
- Multiple primary keys support, a significant enhancement by dubusster in 31 🎉.
- Option to disable the count in `get_multi` and `get_multi_joined` methods for performance optimization.
- Fixes for a validation bug when `return_as_model` is set to `True`.
- Resolution of a bug concerning incorrect handling of `db_row` in methods.
- Correction of the `valid_methods` bug, which previously raised the wrong error type.
- Upgrade of `FastAPI` dependency to version `0.111.0`, ensuring compatibility with the latest FastAPI features.
- Achievement of 100% test coverage, with the addition of a workflow and badge to showcase this milestone.
- Inclusion of the changelog within the project documentation, providing a comprehensive history of changes directly to users.

Detailed Changes

Multiple Primary Keys Support
CRUDFastAPI now accommodates models with multiple primary keys, facilitating more complex database designs. For models defined with more than one primary key, the endpoint creator automatically generates paths reflecting the primary keys' order. This feature extends support to primary keys named differently than `id`, enhancing the flexibility of CRUDFastAPI's routing capabilities.

Example:
For a model with multiple primary keys, CRUDFastAPI generates specific endpoints such as `/multi_pk/get/{id}/{uuid}`, accommodating the unique identification needs of complex data models.

Optional Count
The `get_multi` and `get_multi_joined` methods now feature an `return_total_count=False` parameter, allowing users to opt-out of receiving the total count in responses. This option can enhance performance by skipping potentially expensive count operations.

Behavior:
- By default, `return_total_count=True` is assumed, returning both data and a total count.
- When set to `False`, responses contain only the data array, omitting the total count for efficiency.

What's Changed
- Implementation of multiple primary keys support, addressing a significant flexibility requirement for advanced use cases.
- Introduction of optional count retrieval in multi-get methods, optimizing performance by eliminating unnecessary database queries.
- Several critical bug fixes, improving the stability and reliability of CRUDFastAPI.
- Documentation enhancements, including the addition of a changelog section, ensuring users have access to detailed release information.
- Update to FastAPI `0.111.0`, ensuring compatibility with the latest enhancements in the FastAPI ecosystem.
- Achievement of 100% test coverage, marking a significant milestone in the project's commitment to reliability and quality assurance.

Relevant Contributors
- [dubusster](https://github.com/dubusster) made a notable contribution with the implementation of multiple primary keys support in PR #31.

**Full Changelog**: [View the full changelog](https://github.com/mithun2003/CRUDFastAPI/compare/v0.10.0...v0.11.0)

0.10.0

Added
- `select` statement functionality, thanks to dubusster's contribution in PR 28 🚀.
- Support for joined models in the `count` method through the `joins_config` parameter.
- Filters for joined models via the `filters` parameter in `JoinConfig`.
- Type checking workflow integrated with `mypy` alongside fixes for typing issues.
- Linting workflow established with `ruff`.

Detailed Changes

Select
The `select` method constructs a SQL Alchemy `Select` statement, offering flexibility in column selection, filtering, and sorting. It is designed to chain additional SQLAlchemy methods for complex queries.
[Docs here](https://mithun2003.github.io/CRUDFastAPI/usage/crud/#5-select) and [here](https://mithun2003.github.io/CRUDFastAPI/advanced/crud/#the-select-method).

Features:
- **Column Selection**: Choose columns via a Pydantic schema.
- **Sorting**: Define columns and their order for sorting.
- **Filtering**: Directly apply filters through keyword arguments.
- **Chaining**: Allow for chaining with other SQLAlchemy methods for advanced query construction.

Improved Joins
`JoinConfig` enhances CRUDFastAPI queries by detailing join operations between models, offering configurations like model joining, conditions, prefixes, column selection through schemas, join types, aliases, and direct filtering. [Docs here](https://mithun2003.github.io/CRUDFastAPI/advanced/joins/).

Applying Joins in CRUDFastAPI Methods
Detailed explanations and examples are provided for using joins in `count`, `get_joined`, and `get_multi_joined` methods to achieve complex data retrieval, including handling of many-to-many relationships.

What's Changed
- New `select` statement functionality added.
- Documentation and method improvements for select and joins.
- Integration of type checking and linting workflows.
- Version bump in pyproject.toml.

New Contributors
- [dubusster](https://github.com/dubusster) made their first contribution in PR #28.

**Full Changelog**: [View the full changelog](https://github.com/mithun2003/CRUDFastAPI/compare/v0.9.1...v0.10.0)

___

0.9.1

Added
- Enhanced `get_joined` and `get_multi_joined` methods to support aliases, enabling multiple joins on the same model. This improvement addresses issue 27.

Detailed Changes

Alias Support for Complex Joins
With the introduction of alias support, `get_joined` and `get_multi_joined` methods now allow for more complex queries, particularly beneficial in scenarios requiring self-joins or multiple joins on the same table. Aliases help to avoid conflicts and ambiguity by providing unique identifiers for the same model in different join contexts. [Docs here](https://mithun2003.github.io/CRUDFastAPI/advanced/joins/#complex-joins-using-joinconfig).

Example: Multiple Joins with Aliases
To demonstrate the use of aliases, consider a task management system where tasks are associated with both an owner and an assigned user from the same `UserModel`. Aliases enable joining the `UserModel` twice under different contexts - as an owner and an assigned user. This example showcases how to set up aliases using the `aliased` function and incorporate them into your `JoinConfig` for clear and conflict-free query construction. [Docs here](https://mithun2003.github.io/CRUDFastAPI/advanced/crud/#example-joining-the-same-model-multiple-times).

What's Changed
- Introduction of aliases in joins, improving query flexibility and expressiveness, as detailed by mithun2003 in PR 29.

**Full Changelog**: [View the full changelog](https://github.com/mithun2003/CRUDFastAPI/compare/v0.9.0...v0.9.1)

___

Page 1 of 3

© 2024 Safety CLI Cybersecurity Inc. All Rights Reserved.