Hello,

I am looking at modifying your crudrouter to work with Marmelab's react-admin.

To work with their Listview, I added pagination, sort column and order, column filter and result count to the get_all function.

To work with their Edit and Create views, I have permissions rules on the front end but I would like to have some on the backend too.

I added a dependency to the router and check there the authenticated status. I suppose I could extend it to check the method and path and allow / restrict access based on this and permissions. However I thought it would also be convenient to have different dependencies per route/function as these rules might be different from collection to collection.

Something like this:

users_router = SQLAlchemyCRUDRouter(
    schema=User,
    create_schema=UserCreate,
    db_model=UserModel,
    db=get_db,
    prefix='users',
    dependencies=[Depends(token_auth)],
    delete_one_route_dependencies=[Depends(must_be_admin)],
    delete_all_route_dependencies=[Depends(must_be_admin)],
)

I am not sure this is a good idea but if it seems interesting, where would you suggest I look at implementing this? I looked in your code but was not sure if this should be in CRUDGenerator or in add_api_route.

In any case, great project, thank you !

Hi,

Since I am lazy and want the tools to do boring work for me I installed and used:

• flake8 - to check styles, pep8, complexity etc. with set of plugins to check different style related issues
• black - installed with flake8 (one of plugins) to format code in a consistent way -> always the same regardless who is making the change, I especially like how it breaks long lines
• mypy - to check the types annotations

I also modified the code to pass all those test/ tools which mean a lot of minor changes basically everywhere, added missing types, fixed types enough to pass mypy checks (although it's not done fully), remove unused imports, reorder import etc. You still have few minor issues like some too complex methods according to those checks but that I didn't want to change.

I also extracted creation of the items in pagination tests into fixtures and changed it's scope (scope is now class so they run once per implementation), as before they were running per every parametrization and in effect the tests for all backends were running several minutes and now they run like 40s, and tests should run quickly or you end up not running them often enough. Since you test creation in the separate tests I think it's beneficial as you do not create the same items 20-30 times in those few tests.

I know that you might not like such a massive changes (although they are all style related - there is no logic change - apart from ormar implementation of course :) ), so if you refuse it we can just extract ormar files (tests and backend) with docs.

It was still easier for me to check my ormar implementation this way even if you would want to discard those changes.

But I think the project would benefit from tiding up that was done in this PR, so please review the PR and let me know what you think.

I'm mixing this project and FastAPI-Users together so I have a very basic DatabasesCRUDRouter that has delete_all_route disabled and the delete_one_route has FastAPI-Users dependency for superuser on it. Otherwise, nothing else interacts with the delete endpoints yet when I delete an item I'm returned with 404 error and the detail says the item is not found.

The item is deleted though.

from fastapi import Depends
from fastapi_crudrouter import DatabasesCRUDRouter

from app.core.users import fastapi_users
from app.db.session import database
from app.models.thing import Thing as ThingTable 
from app.schemas.thing import ThingCreate, Thing

current_active_verified_user = fastapi_users.current_user(active=True, verified=True)
current_superuser = fastapi_users.current_user(active=True, superuser=True)

thing_db = ThingTable.__table__

router = DatabasesCRUDRouter(
    prefix="things",
    tags=["things"],
    schema=Thing,
    create_schema=ThingCreate,
    table=thing_db,
    database=database,
    # Disable delete_all endpoint
    delete_all_route=False,
    # Dependencies for endpoints
    create_route=[Depends(current_active_verified_user)],
    update_route=[Depends(current_active_verified_user)],
    delete_one_route=[Depends(current_superuser)],
)

Closes #103, #102

PR Includes 404 responses for the retrieve, update, and delete endpoints.

Context

I started working on this thinking that crudrouter manually documented the 200 and 422 response, but I've come to suspect that this is built-into FastAPI - is that right?

Passing responses to fastapi.routing.add_api_route seems to satisfy the wip test I created. I also tested with

Left to do

Before finalizing, I was hoping to run the test suite here @awtkns - I had some trouble setting up some of the test requirements locally 👏 And please let me know if you have any suggestions for improvement.

And if you have any ideas about where to include tests, that would be great! So far I just put a wip test in test_openapi_schema.py which seemed fitting.

Resolves #156

• Adds pyproject.toml with poetry config.
• Adds poetry.lock — all dependencies are here.
• Updates requirements.txt and dev.requirements.txt — exported from poetry, so no conflicting package versions are installed.
• Updates contributing.md with info about poetry.
• Changes psycopg2 to psycopg2-binary to avoid building psycopg2.

Hello.

I'm trying fastapi-crudrouter. Unfortunetly, I'm experiencing an unrecognized issue:

ModuleNotFoundError: No module named 'fastapi_crudrouter'

I have virtualenv with fastapi-crudrouter installed

rom pydantic import  BaseModel
from fastapi import FastAPI
from fastapi_crudrouter import MemoryCRUDRouter as CRUDRouter


class Potato(BaseModel):
    id: int
    color: str
    mass: float

app = FastAPI()

app.include_router(CRUDRouter(schema=Potato))

requiremnts.txt

fastapi==0.68.1
fastapi-crudrouter==0.8.1
pydantic==1.8.2
starlette==0.14.2
typing-extensions==3.10.0.2

Hello, I would like to know if there is a way to have "lazy loading" using crudrouter on fastapi? Is there a solution or a manner to do it? Thank you in advance.

So I run into an import error for the testclient when I try and run the tests but in theory everything works for the test implementation and I tested it by hand and it should behave the same way as the others!

I use a JSONB column in Postgres, but I do get an error on the GET all route with my specified pydantic model with json_field: Optional[pydantic.Json] = None with proper json data in my database table. The exception is:

..../python3.9/site-packages/fastapi/routing.py", line 137, in serialize_response
    raise ValidationError(errors, field.type_)
pydantic.error_wrappers.ValidationError: 2 validation errors for MyModel
response -> 0
  value is not a valid dict (type=type_error.dict)

Any idea how to fix that? Thanks.

Hello,

So as discussed in #37

I think this might be how to make a pull request so I give it a try.

If this is not needed or too late, it's fine, I am glad to learn!

closes #59 #37

fastapi 0.63.0 fastapi-crudrouter 0.6.1

Trying to use SQLAlchemyCRUDRouter for joined tables , All endpoints created automatically (amazing:)).

Tried using the "create one " for input:

{
  "customer_no": 1,
  "subscriber": [
    {
      "subscriber_no": 1,
      "is_active": false,
      "owner": 1
    }
  ]
}

End up with error:

File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/state.py", line 434, in _initialize_instance
    return manager.original_init(*mixed[1:], **kwargs)
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/decl_base.py", line 1086, in _declarative_constructor
    setattr(self, k, kwargs[k])
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/attributes.py", line 427, in __set__
    self.impl.set(
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/attributes.py", line 1512, in set
    collections.bulk_replace(
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/collections.py", line 817, in bulk_replace
    appender(member, _sa_initiator=initiator)
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/collections.py", line 1131, in append
    item = __set(self, item, _sa_initiator)
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/collections.py", line 1096, in __set
    item = executor.fire_append_event(item, _sa_initiator)
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/collections.py", line 727, in fire_append_event
    return self.attr.fire_append_event(
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/attributes.py", line 1345, in fire_append_event
    value = fn(state, value, initiator or self._append_token)
  File "/usr/local/lib/python3.8/site-packages/sqlalchemy/orm/attributes.py", line 1675, in emit_backref_from_collection_append_event
    child_state, child_dict = instance_state(child), instance_dict(child)
AttributeError: 'dict' object has no attribute '_sa_instance_state'

Code:

Routes:

from config.config import postgress_engine,SessionLocal
from fastapi_crudrouter impor SQLAlchemyCRUDRouter as SQLDBCrudRouter

customer_router = APIRouter()

def get_db():
    session = SessionLocal()
    try:
        yield session
        session.commit()
    finally:
        session.close()


customer_router = SQLDBCrudRouter(schema=Customer,create_schema=CustomerCreate,
             db_model=CustomerModel,db=get_db,prefix='customer')

schemas.py

from pydantic import BaseModel
from typing import List, Optional


class SubscriberBase(BaseModel):
    subscriber_no: int
    is_active: bool = False

class SubscriberCreate(BaseModel):
    pass


class Subscriber(SubscriberBase):
    owner: int

    class Config:
        orm_mode = True

class CustomerCreate(BaseModel):
    customer_no: Optional[int] = None
    subscriber: Optional[List[Subscriber]] =None

class Customer(CustomerCreate):
    id: int
    class Config:
        orm_mode = True

models.py

from sqlalchemy import Boolean, Column, ForeignKey, Integer, String,DateTime
from sqlalchemy.orm import relationship
from config.config import Base


class CustomerModel(Base):
    __tablename__ = 'customer'
    id = Column(Integer, primary_key=True, index=True)
    customer_no= Column(Integer,index=True)
    subscriber= relationship("SubscriberModel", back_populates="owner")


class SubscriberModel(Base):
    __tablename__ = 'subscriber'
    id = Column(Integer, ForeignKey("customer.id"))
    subscriber_no= Column(Integer, primary_key=True, index=True)
    owner = relationship("CustomerModel", back_populates="subscriber")

As mentioned in #163 a feature request to customize the item_id parameter name in the OpenAPI specification was requested. I implemented it and added some extra tests and documentation for it.

I would be very thankful if you would add the HACKTOBERFEST-ACCEPTED to this pull request.

Hope this helps. Thanks in advance.

This is something I've implemented for sqlalchemy at my day job. Wondering if it's useful to others...

For one-2-many and many-2-many relationships, it would be nice to allow the create and update routes to accept a partial object in the foreign key attribute. For example:

client.post("/heros", json={
    "name": Bob,
    "team": {"name": "Avengers"}
}

As is today, you need to do the following:

client.post("/heros", json={
    "name": Bob,
    "team_id": 42
}

I've created PR https://github.com/awtkns/fastapi-crudrouter/pull/171 with an initial implementation. Would appreciate feedback. I'm not 100% happy with the way that I've connected the read and table objects and would welcome ideas on that.

One other feature that would be nice would be to allow for sub-object creation. That could be enabled at the route level with some arg. I don't have a need for that right now, but would be good for a full solution.

I've only implemented this for SQLAlchemy as that's all I'm using right now. Would probably be applicable to other back-ends as well.

For one-2-many and many-2-many relationships, allow the create and update routes to accept a partial object in the foreign key attribute. For example:

client.post("/heros", json={
    "name": Bob,
    "team": {"name": "Avengers"}
}

Assuming there is already a team called Avengers, Bob will be created, the Team with name "Avengers" will be looked up and used to populate Bob's team_id foreign key attribute.

The only setup required is for the input model for the foreign object to specify the Table class that can be used to lookup the object.

For example:

class Team(Base):
    """Team DTO."""

    __tablename__ = "teams"

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, unique=True)

class TeamUpdate(Model):
    name: str

    class Meta:
        orm_model = Team

Currently, only tortoise and ormar backends are allowing partial updates. See relevant line for tortoise below.

https://github.com/awtkns/fastapi-crudrouter/blob/66fd32fafaf191c58c388eb8a849dddef6e569a4/fastapi_crudrouter/core/tortoise.py#L95

Behaviour should be consistent across all backends when possible.

Requirement of fields should be determined by pydantic model as its primary function is validation. Currently, marking a field of pydantic model as Optional or setting a default value doesn't allow skipping that field when sending a request (for backends other than tortoise and ormar).

Making this change would allow to both keeping the current behaviour and enabling partial updates depending on your pydantic model.

I can create a pull request for this if it gets approved. I have already tested it in my local environment and doesn't seem to break anything else.

Generally, define the sql model as SQLALCHEMY. The models extends Base. Parent of base is Model, but type of child Model is not Model. Therefore I fix type of db_model in SQLAlchemyCRUDRouter.

Finally warnning is shutdown.