Skip to content
The Chat Archive
gpt-3.5-turbo-0613· OpenAI WildChat-4.8M (AI2)

Fastapi. Для работы с товарами создай сервис и репозиторий. С возможностью постраничной…

  1. User

    Fastapi. Для работы с товарами создай сервис и репозиторий. С возможностью постраничной навигации и фильтрации

  2. Assistant

    Вот пример кода для создания сервиса и репозитория для работы с товарами с использованием FastAPI:

    Создайте файл "service.py" и добавьте следующий код:

    from typing import List
    
    from fastapi import HTTPException
    from sqlalchemy.orm import Session
    
    from . import crud, models, schemas
    
    
    class ProductService:
        def __init__(self, db: Session):
            self.db = db
    
        def get_product(self, product_id: int) -> schemas.Product:
            product = crud.get_product(self.db, product_id)
            if not product:
                raise HTTPException(status_code=404, detail="Product not found")
            return product
    
        def get_products(
            self,
            skip: int = 0,
            limit: int = 100,
            min_price: float = None,
            max_price: float = None,
        ) -> List[schemas.Product]:
            products = crud.get_products(
                self.db, skip=skip, limit=limit, min_price=min_price, max_price=max_price
            )
            return products
    
        def create_product(self, product: schemas.ProductCreate) -> schemas.Product:
            db_product = crud.create_product(self.db, product)
            return db_product
    
    
    class ProductRepository:
        def __init__(self, db: Session):
            self.db = db
    
        def get_product(self, product_id: int) -> models.Product:
            return self.db.query(models.Product).filter(models.Product.id == product_id).first()
    
        def get_products(
            self,
            skip: int = 0,
            limit: int = 100,
            min_price: float = None,
            max_price: float = None,
        ) -> List[models.Product]:
            query = self.db.query(models.Product)
            if min_price is not None:
                query = query.filter(models.Product.price >= min_price)
            if max_price is not None:
                query = query.filter(models.Product.price <= max_price)
            return query.offset(skip).limit(limit).all()
    
        def create_product(self, product: schemas.ProductCreate) -> models.Product:
            db_product = models.Product(**product.dict())
            self.db.add(db_product)
            self.db.commit()
            self.db.refresh(db_product)
            return db_product
    

    Создайте файл "main.py" и добавьте следующий код:

    from fastapi import FastAPI, Query
    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    
    from . import models, schemas, service
    
    
    app = FastAPI()
    
    engine = create_engine("sqlite:///./test.db")
    SessionLocal = sessionmaker(bind=engine)
    
    
    @app.on_event("startup")
    def startup_event():
        models.Base.metadata.create_all(bind=engine)
    
    
    @app.on_event("shutdown")
    def shutdown_event():
        models.Base.metadata.drop_all(bind=engine)
    
    
    def get_db():
        db = SessionLocal()
        try:
            yield db
        finally:
            db.close()
    
    
    @app.post("/products/", response_model=schemas.Product)
    async def create_product(
        product: schemas.ProductCreate,
        product_service: service.ProductService = service.ProductService(get_db()),
    ):
        return product_service.create_product(product)
    
    
    @app.get("/products/{product_id}", response_model=schemas.Product)
    async def read_product(
        product_id: int,
        product_service: service.ProductService = service.ProductService(get_db()),
    ):
        return product_service.get_product(product_id)
    
    
    @app.get("/products/", response_model=List[schemas.Product])
    async def read_products(
        skip: int = 0,
        limit: int = 100,
        min_price: float = Query(None, ge=0),
        max_price: float = Query(None, ge=0),
        product_service: service.ProductService = service.ProductService(get_db()),
    ):
        return product_service.get_products(skip=skip, limit=limit, min_price=min_price, max_price=max_price)
    

    Теперь вы можете запустить FastAPI-сервер с помощью команды uvicorn main:app --reload и использовать эндпоинты для создания, получения и фильтрации товаров. Приложение будет использовать SQLite базу данных с файлом "test.db" в текущем каталоге.

  3. User

    Сервис, возвращающий составной объект

  4. Assistant

    Для создания сервиса, возвращающего составной объект, вы можете использовать FastAPI в сочетании с моделями данных и схемами.

    Вот пример кода для создания сервиса, возвращающего составной объект:

    Создайте файл "service.py" и добавьте следующий код:

    from fastapi import HTTPException
    from sqlalchemy.orm import Session
    
    from . import crud, models, schemas
    
    
    class CompositeService:
        def __init__(self, db: Session):
            self.db = db
    
        def get_composite_object(self, obj_id: int) -> schemas.CompositeObject:
            obj = crud.get_object(self.db, obj_id)
            if not obj:
                raise HTTPException(status_code=404, detail="Object not found")
            
            sub_obj = crud.get_subobject(self.db, obj.subobject_id)
            if not sub_obj:
                raise HTTPException(status_code=404, detail="Subobject not found")
    
            composite_object = schemas.CompositeObject(
                id=obj.id, name=obj.name, subobject=sub_obj
            )
            return composite_object
    

    Создайте файл "models.py" и добавьте следующий код:

    from sqlalchemy import Column, ForeignKey, Integer, String
    from sqlalchemy.orm import relationship
    
    from .database import Base
    
    
    class Object(Base):
        __tablename__ = "objects"
    
        id = Column(Integer, primary_key=True, index=True)
        name = Column(String)
    
    
    class Subobject(Base):
        __tablename__ = "subobjects"
    
        id = Column(Integer, primary_key=True, index=True)
        name = Column(String)
    
    
    class CompositeObject(Base):
        __tablename__ = "composite_objects"
    
        id = Column(Integer, primary_key=True, index=True)
        object_id = Column(Integer, ForeignKey("objects.id"))
        subobject_id = Column(Integer, ForeignKey("subobjects.id"))
    
        obj = relationship("Object", backref="composite_object", uselist=False)
        sub_obj = relationship("Subobject", backref="composite_object", uselist=False)
    

    Создайте файл "crud.py" и добавьте следующий код:

    from sqlalchemy.orm import Session
    
    from . import models
    
    
    def get_object(db: Session, obj_id: int) -> models.Object:
        return db.query(models.Object).filter(models.Object.id == obj_id).first()
    
    
    def get_subobject(db: Session, sub_obj_id: int) -> models.Subobject:
        return db.query(models.Subobject).filter(models.Subobject.id == sub_obj_id).first()
    

    В вашем main.py файле:

    from fastapi import FastAPI
    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    
    from . import models, service
    
    
    app = FastAPI()
    
    engine = create_engine("sqlite:///./test.db")
    SessionLocal = sessionmaker(bind=engine)
    
    
    @app.on_event("startup")
    def startup_event():
        models.Base.metadata.create_all(bind=engine)
    
    
    @app.on_event("shutdown")
    def shutdown_event():
        models.Base.metadata.drop_all(bind=engine)
    
    
    def get_db():
        db = SessionLocal()
        try:
            yield db
        finally:
            db.close()
    
    
    @app.get("/composite-objects/{obj_id}")
    async def read_composite_object(
        obj_id: int,
        composite_service: service.CompositeService = service.CompositeService(get_db()),
    ):
        return composite_service.get_composite_object(obj_id)
    

    Теперь вы можете запустить FastAPI-сервер с помощью команды uvicorn main:app --reload и использовать эндпоинт для получения составного объекта по его идентификатору. Приложение будет использовать SQLite базу данных с файлом "test.db" в текущем каталоге.

  5. User

    Fastapi. Создай сервис и репозиторий для товара, и сервис и репозиторий для комментариев к товару

  6. Assistant

    Вот пример кода для создания сервиса и репозитория для товара и комментариев к товару с использованием FastAPI:

    Создайте файл "product_service.py" и добавьте следующий код:

    from typing import List
    
    from fastapi import HTTPException
    from sqlalchemy.orm import Session
    
    from . import crud, models, schemas
    
    
    class ProductService:
        def __init__(self, db: Session):
            self.db = db
    
        def get_product(self, product_id: int) -> schemas.Product:
            product = crud.get_product(self.db, product_id)
            if not product:
                raise HTTPException(status_code=404, detail="Product not found")
            return product
    
        def get_products(
            self,
            skip: int = 0,
            limit: int = 100,
            min_price: float = None,
            max_price: float = None,
        ) -> List[schemas.Product]:
            products = crud.get_products(
                self.db, skip=skip, limit=limit, min_price=min_price, max_price=max_price
            )
            return products
    
        def create_product(self, product: schemas.ProductCreate) -> schemas.Product:
            db_product = crud.create_product(self.db, product)
            return db_product
    
    
    class ProductRepository:
        def __init__(self, db: Session):
            self.db = db
    
        def get_product(self, product_id: int) -> models.Product:
            return self.db.query(models.Product).filter(models.Product.id == product_id).first()
    
        def get_products(
            self,
            skip: int = 0,
            limit: int = 100,
            min_price: float = None,
            max_price: float = None,
        ) -> List[models.Product]:
            query = self.db.query(models.Product)
            if min_price is not None:
                query = query.filter(models.Product.price >= min_price)
            if max_price is not None:
                query = query.filter(models.Product.price <= max_price)
            return query.offset(skip).limit(limit).all()
    
        def create_product(self, product: schemas.ProductCreate) -> models.Product:
            db_product = models.Product(**product.dict())
            self.db.add(db_product)
            self.db.commit()
            self.db.refresh(db_product)
            return db_product
    

    Создайте файл "comment_service.py" и добавьте следующий код:

    from typing import List
    
    from fastapi import HTTPException
    from sqlalchemy.orm import Session
    
    from . import crud, models, schemas
    
    
    class CommentService:
        def __init__(self, db: Session):
            self.db = db
    
        def get_comment(self, comment_id: int) -> schemas.Comment:
            comment = crud.get_comment(self.db, comment_id)
            if not comment:
                raise HTTPException(status_code=404, detail="Comment not found")
            return comment
    
        def get_comments_by_product(
            self, product_id: int, skip: int = 0, limit: int = 100
        ) -> List[schemas.Comment]:
            comments = crud.get_comments_by_product(self.db, product_id, skip=skip, limit=limit)
            return comments
    
        def create_comment(self, comment: schemas.CommentCreate) -> schemas.Comment:
            db_comment = crud.create_comment(self.db, comment)
            return db_comment
    
    
    class CommentRepository:
        def __init__(self, db: Session):
            self.db = db
    
        def get_comment(self, comment_id: int) -> models.Comment:
            return self.db.query(models.Comment).filter(models.Comment.id == comment_id).first()
    
        def get_comments_by_product(
            self, product_id: int, skip: int = 0, limit: int = 100
        ) -> List[models.Comment]:
            return (
                self.db.query(models.Comment)
                .filter(models.Comment.product_id == product_id)
                .offset(skip)
                .limit(limit)
                .all()
            )
    
        def create_comment(self, comment: schemas.CommentCreate) -> models.Comment:
            db_comment = models.Comment(**comment.dict())
            self.db.add(db_comment)
            self.db.commit()
            self.db.refresh(db_comment)
            return db_comment
    

    Теперь вы можете использовать созданные сервисы и репозитории для работы с товарами и комментариями к товарам в вашем FastAPI-приложении.

  7. User

    Добавь метод, который возвращает товар вместе с комментариями к нему

  8. Assistant

    Для добавления метода, который возвращает товар вместе с комментариями к нему, вам потребуется изменить класс ProductService и класс ProductRepository.

    Вот измененный код:

    from typing import List
    
    from fastapi import HTTPException
    from sqlalchemy.orm import Session
    
    from . import crud, models, schemas
    
    
    class ProductService:
        def __init__(self, db: Session):
            self.db = db
    
        def get_product_with_comments(self, product_id: int) -> schemas.ProductWithComments:
            product = crud.get_product(self.db, product_id)
            if not product:
                raise HTTPException(status_code=404, detail="Product not found")
            
            comments = crud.get_comments_by_product(self.db, product_id)
            product_with_comments = schemas.ProductWithComments(
                id=product.id, name=product.name, price=product.price, comments=comments
            )
            return product_with_comments
    
        # Остальные методы
    
    from typing import List
    
    from sqlalchemy.orm import Session
    
    from . import models
    
    
    class ProductRepository:
        def __init__(self, db: Session):
            self.db = db
    
        def get_product(self, product_id: int) -> models.Product:
            return self.db.query(models.Product).filter(models.Product.id == product_id).first()
    
        def get_product_with_comments(self, product_id: int) -> models.Product:
            return (
                self.db.query(models.Product)
                .options(models.joinedload(models.Product.comments))
                .filter(models.Product.id == product_id)
                .first()
            )
    
        # Остальные методы
    

    Затем в вашем main.py файле, в методе read_product, вызовите измененную версию get_product_with_comments:

    @app.get("/products/{product_id}", response_model=schemas.ProductWithComments)
    async def read_product(
        product_id: int,
        product_service: service.ProductService = service.ProductService(get_db()),
    ):
        return product_service.get_product_with_comments(product_id)
    

    Теперь, когда вы вызываете эндпоинт /products/{product_id}, вы будете получать информацию о товаре вместе со списком комментариев к нему.