plexus-python-pulse-demeter 1.1.126__py3-none-any.whl

plexus/pulse/demeter/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("plexus-python-pulse-demeter")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"

plexus/pulse/demeter/app/api/__init__.py

@@ -0,0 +1,44 @@
+import datetime
+from collections.abc import Generator
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from plexus.common.utils.dtutils import dt_utc_now
+
+__all__ = [
+    "current_dt_clock",
+    "make_api"
+]
+
+
+def current_dt_clock() -> Generator[datetime.datetime, None, None]:
+    yield dt_utc_now()
+
+
+def make_api() -> FastAPI:
+    from plexus.pulse.demeter.app.api.dataset_internal_endpoints import router as dataset_internal_router
+    from plexus.pulse.demeter.app.api.dataset_public_endpoints import router as dataset_public_router
+    from plexus.pulse.demeter.app.api.dataset_workflow_endpoints import router as dataset_workflow_router
+    from plexus.pulse.demeter.app.api.archive_internal_endpoints import router as archive_internal_router
+    from plexus.pulse.demeter.app.api.archive_public_endpoints import router as archive_public_router
+    from plexus.pulse.demeter.app.api.tagging_endpoints import router as tagging_router
+    from plexus.pulse.demeter.app.api.user_endpoints import router as user_router
+
+    api = FastAPI(title="Pulse Demeter API", description="API for Pulse Demeter")
+    api.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    api.include_router(dataset_internal_router)
+    api.include_router(dataset_public_router)
+    api.include_router(dataset_workflow_router)
+    api.include_router(archive_internal_router)
+    api.include_router(archive_public_router)
+    api.include_router(tagging_router)
+    api.include_router(user_router)
+
+    return api

plexus/pulse/demeter/app/api/archive_internal_endpoints.py

@@ -0,0 +1,316 @@
+import datetime
+
+import sqlalchemy.orm as sa_orm
+from fastapi import APIRouter, Depends
+from fastapi.params import Query
+from plexus.common.utils.dtutils import dt_utc_now
+from plexus.pulse.common.utils.apiutils import managed_db_session
+from plexus.pulse.common.utils.ormutils import (
+    db_create_revision_model,
+    db_create_revision_models,
+    db_expire_revision_model,
+    db_read_active_revision_model_of_record,
+    db_read_active_revision_models,
+    db_update_revision_model,
+)
+
+from plexus.pulse.demeter.app.core.database import make_session
+from plexus.pulse.demeter.app.models.registry.archive import (
+    RegisteredBag as Bag,
+    RegisteredBagTable as BagTable,
+    Sensor,
+    SensorTable,
+    SensorTemplate,
+    SensorTemplateTable,
+    Vehicle,
+    VehicleTable,
+    VehicleTemplate,
+    VehicleTemplateTable,
+)
+
+router = APIRouter(prefix="/pulse_demeter/archive_internal", tags=["archive_internal"])
+
+
+@router.post("/vehicle_template/", response_model=VehicleTemplateTable)
+def create_vehicle_template(
+    vehicle_template: VehicleTemplate,
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTemplateTable:
+    with managed_db_session(db):
+        return db_create_revision_model(db, VehicleTemplateTable, vehicle_template, created_at)
+
+
+@router.post("/vehicle_templates/", response_model=list[VehicleTemplateTable])
+def create_vehicle_templates(
+    vehicle_templates: list[VehicleTemplate],
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[VehicleTemplateTable]:
+    with managed_db_session(db):
+        return db_create_revision_models(db, VehicleTemplateTable, vehicle_templates, created_at)
+
+
+@router.get("/vehicle_template/{record_sqn}", response_model=VehicleTemplateTable)
+def read_vehicle_template(record_sqn: int, db: sa_orm.Session = Depends(make_session)) -> VehicleTemplateTable:
+    with managed_db_session(db):
+        return db_read_active_revision_model_of_record(db, VehicleTemplateTable, record_sqn)
+
+
+@router.get("/vehicle_templates/", response_model=list[VehicleTemplateTable])
+def read_vehicle_templates(
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[VehicleTemplateTable]:
+    with managed_db_session(db):
+        return db_read_active_revision_models(db, VehicleTemplateTable, skip, limit)
+
+
+@router.put("/vehicle_template/{record_sqn}", response_model=VehicleTemplateTable)
+def update_vehicle_template(
+    record_sqn: int,
+    vehicle_template: VehicleTemplate,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTemplateTable:
+    with managed_db_session(db):
+        return db_update_revision_model(db, VehicleTemplateTable, vehicle_template, record_sqn, updated_at)
+
+
+@router.delete("/vehicle_template/{record_sqn}", response_model=VehicleTemplateTable)
+def delete_vehicle_template(
+    record_sqn: int,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTemplateTable:
+    with managed_db_session(db):
+        return db_expire_revision_model(db, VehicleTemplateTable, record_sqn, updated_at)
+
+
+@router.post("/sensor_template/", response_model=SensorTemplateTable)
+def create_sensor_template(
+    sensor_template: SensorTemplate,
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTemplateTable:
+    with managed_db_session(db):
+        return db_create_revision_model(db, SensorTemplateTable, sensor_template, created_at)
+
+
+@router.post("/sensor_templates/", response_model=list[SensorTemplateTable])
+def create_sensor_templates(
+    sensor_templates: list[SensorTemplate],
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[SensorTemplateTable]:
+    with managed_db_session(db):
+        return db_create_revision_models(db, SensorTemplateTable, sensor_templates, created_at)
+
+
+@router.get("/sensor_template/{record_sqn}", response_model=SensorTemplateTable)
+def read_sensor_template(record_sqn: int, db: sa_orm.Session = Depends(make_session)) -> SensorTemplateTable:
+    with managed_db_session(db):
+        return db_read_active_revision_model_of_record(db, SensorTemplateTable, record_sqn)
+
+
+@router.get("/sensor_templates/", response_model=list[SensorTemplateTable])
+def read_sensor_templates(
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[SensorTemplateTable]:
+    with managed_db_session(db):
+        return db_read_active_revision_models(db, SensorTemplateTable, skip, limit)
+
+
+@router.put("/sensor_template/{record_sqn}", response_model=SensorTemplateTable)
+def update_sensor_template(
+    record_sqn: int,
+    sensor_template: SensorTemplate,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTemplateTable:
+    with managed_db_session(db):
+        return db_update_revision_model(db, SensorTemplateTable, sensor_template, record_sqn, updated_at)
+
+
+@router.delete("/sensor_template/{record_sqn}", response_model=SensorTemplateTable)
+def delete_sensor_template(
+    record_sqn: int,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTemplateTable:
+    with managed_db_session(db):
+        return db_expire_revision_model(db, SensorTemplateTable, record_sqn, updated_at)
+
+
+@router.post("/vehicle/", response_model=VehicleTable)
+def create_vehicle(
+    vehicle: Vehicle,
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTable:
+    with managed_db_session(db):
+        return db_create_revision_model(db, VehicleTable, vehicle, created_at)
+
+
+@router.post("/vehicles/", response_model=list[VehicleTable])
+def create_vehicles(
+    vehicles: list[Vehicle],
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[VehicleTable]:
+    with managed_db_session(db):
+        return db_create_revision_models(db, VehicleTable, vehicles, created_at)
+
+
+@router.get("/vehicle/{record_sqn}", response_model=VehicleTable)
+def read_vehicle(record_sqn: int, db: sa_orm.Session = Depends(make_session)) -> VehicleTable:
+    with managed_db_session(db):
+        return db_read_active_revision_model_of_record(db, VehicleTable, record_sqn)
+
+
+@router.get("/vehicles/", response_model=list[VehicleTable])
+def read_vehicles(
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[VehicleTable]:
+    with managed_db_session(db):
+        return db_read_active_revision_models(db, VehicleTable, skip, limit)
+
+
+@router.put("/vehicle/{record_sqn}", response_model=VehicleTable)
+def update_vehicle(
+    record_sqn: int,
+    vehicle: Vehicle,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTable:
+    with managed_db_session(db):
+        return db_update_revision_model(db, VehicleTable, vehicle, record_sqn, updated_at)
+
+
+@router.delete("/vehicle/{record_sqn}", response_model=VehicleTable)
+def delete_vehicle(
+    record_sqn: int,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTable:
+    with managed_db_session(db):
+        return db_expire_revision_model(db, VehicleTable, record_sqn, updated_at)
+
+
+@router.post("/sensor/", response_model=SensorTable)
+def create_sensor(
+    sensor: Sensor,
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTable:
+    with managed_db_session(db):
+        return db_create_revision_model(db, SensorTable, sensor, created_at)
+
+
+@router.post("/sensors/", response_model=list[SensorTable])
+def create_sensors(
+    sensors: list[Sensor],
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[SensorTable]:
+    with managed_db_session(db):
+        return db_create_revision_models(db, SensorTable, sensors, created_at)
+
+
+@router.get("/sensor/{record_sqn}", response_model=SensorTable)
+def read_sensor(record_sqn: int, db: sa_orm.Session = Depends(make_session)) -> SensorTable:
+    with managed_db_session(db):
+        return db_read_active_revision_model_of_record(db, SensorTable, record_sqn)
+
+
+@router.get("/sensors/", response_model=list[SensorTable])
+def read_sensors(
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[SensorTable]:
+    with managed_db_session(db):
+        return db_read_active_revision_models(db, SensorTable, skip, limit)
+
+
+@router.put("/sensor/{record_sqn}", response_model=SensorTable)
+def update_sensor(
+    record_sqn: int,
+    sensor: Sensor,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTable:
+    with managed_db_session(db):
+        return db_update_revision_model(db, SensorTable, sensor, record_sqn, updated_at)
+
+
+@router.delete("/sensor/{record_sqn}", response_model=SensorTable)
+def delete_sensor(
+    record_sqn: int,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTable:
+    with managed_db_session(db):
+        return db_expire_revision_model(db, SensorTable, record_sqn, updated_at)
+
+
+@router.post("/bag/", response_model=BagTable)
+def create_bag(
+    bag: Bag,
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> BagTable:
+    with managed_db_session(db):
+        return db_create_revision_model(db, BagTable, bag, created_at)
+
+
+@router.post("/bags/", response_model=list[BagTable])
+def create_bags(
+    bags: list[Bag],
+    created_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[BagTable]:
+    with managed_db_session(db):
+        return db_create_revision_models(db, BagTable, bags, created_at)
+
+
+@router.get("/bag/{record_sqn}", response_model=BagTable)
+def read_bag(record_sqn: int, db: sa_orm.Session = Depends(make_session)) -> BagTable:
+    with managed_db_session(db):
+        return db_read_active_revision_model_of_record(db, BagTable, record_sqn)
+
+
+@router.get("/bags/", response_model=list[BagTable])
+def read_bags(
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> list[BagTable]:
+    with managed_db_session(db):
+        return db_read_active_revision_models(db, BagTable, skip, limit)
+
+
+@router.put("/bag/{record_sqn}", response_model=BagTable)
+def update_bag(
+    record_sqn: int,
+    bag: Bag,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> BagTable:
+    with managed_db_session(db):
+        return db_update_revision_model(db, BagTable, bag, record_sqn, updated_at)
+
+
+@router.delete("/bag/{record_sqn}", response_model=BagTable)
+def delete_bag(
+    record_sqn: int,
+    updated_at: datetime.datetime = Query(default_factory=dt_utc_now),
+    db: sa_orm.Session = Depends(make_session),
+) -> BagTable:
+    with managed_db_session(db):
+        return db_expire_revision_model(db, BagTable, record_sqn, updated_at)

plexus/pulse/demeter/app/api/archive_public_endpoints.py

@@ -0,0 +1,255 @@
+import datetime
+
+import pydantic as pdt
+import sqlalchemy as sa
+import sqlalchemy.exc as sa_exc
+import sqlalchemy.orm as sa_orm
+from fastapi import APIRouter, Body, Depends, Query
+from plexus.pulse.common.utils.apiutils import managed_db_session
+from plexus.pulse.common.utils.ormutils import model_name_of
+from plexus.pulse.common.utils.sqlutils import escape_sql_like
+
+from plexus.pulse.demeter.app.api import current_dt_clock
+from plexus.pulse.demeter.app.api.archive_internal_endpoints import (
+    create_bag,
+    create_sensor,
+    create_vehicle,
+    update_bag,
+    update_sensor,
+    update_vehicle,
+)
+from plexus.pulse.demeter.app.core.database import make_session
+from plexus.pulse.demeter.app.models import Pagination
+from plexus.pulse.demeter.app.models.registry.archive import (
+    RegisteredBag as Bag,
+    RegisteredBagTable as BagTable,
+    Sensor,
+    SensorTable,
+    Vehicle,
+    VehicleTable,
+)
+
+router = APIRouter(prefix="/pulse_demeter/archive_public", tags=["archive_public"])
+
+
+@router.post("/create_or_update_sensor/", response_model=SensorTable)
+def create_or_update_sensor(
+    sensor: Sensor = Body(),
+    current_dt: datetime.datetime = Depends(current_dt_clock),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTable:
+    with managed_db_session(db):
+        db_sensor = (
+            db
+            .query(SensorTable)
+            .where(SensorTable.expired_at.is_(None),
+                   SensorTable.uuid == sensor.uuid,
+                   SensorTable.serial_number == sensor.serial_number)
+            .one_or_none()
+        )
+        if db_sensor is None:
+            return create_sensor(sensor, current_dt, db)
+        else:
+            return update_sensor(db_sensor.record_sqn, sensor, current_dt, db)
+
+
+@router.post("/create_or_update_vehicle/", response_model=VehicleTable)
+def create_or_update_vehicle(
+    vehicle: Vehicle = Body(),
+    current_dt: datetime.datetime = Depends(current_dt_clock),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTable:
+    with managed_db_session(db):
+        db_vehicle = (
+            db
+            .query(VehicleTable)
+            .where(VehicleTable.expired_at.is_(None),
+                   VehicleTable.vin_code == vehicle.vin_code,
+                   VehicleTable.name == vehicle.name)
+            .one_or_none()
+        )
+        if db_vehicle is None:
+            return create_vehicle(vehicle, current_dt, db)
+        else:
+            return update_vehicle(db_vehicle.record_sqn, vehicle, current_dt, db)
+
+
+@router.post("/create_or_update_bag/", response_model=BagTable)
+def create_or_update_bag(
+    bag: Bag = Body(),
+    current_dt: datetime.datetime = Depends(current_dt_clock),
+    db: sa_orm.Session = Depends(make_session),
+) -> BagTable:
+    with managed_db_session(db):
+        db_bag = (
+            db
+            .query(BagTable)
+            .where(BagTable.expired_at.is_(None),
+                   BagTable.name == bag.name)
+            .one_or_none()
+        )
+        if db_bag is None:
+            return create_bag(bag, current_dt, db)
+        else:
+            return update_bag(db_bag.record_sqn, bag, current_dt, db)
+
+
+class VehicleTablesAndPagination(pdt.BaseModel):
+    vehicles: list[VehicleTable]
+    pagination: Pagination
+
+
+@router.get("/query_vehicles/", response_model=VehicleTablesAndPagination)
+def query_vehicles(
+    effective_at: datetime.datetime | None = Query(None),
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTablesAndPagination:
+    with managed_db_session(db):
+        query_stmt = (
+            db
+            .query(VehicleTable)
+            .where(VehicleTable.updated_at <= effective_at,
+                   sa.or_(VehicleTable.expired_at.is_(None), VehicleTable.expired_at > effective_at))
+        )
+
+        total = query_stmt.count()
+        db_vehicles = query_stmt.order_by(VehicleTable.sqn.asc()).offset(skip).limit(limit).all()
+
+    return VehicleTablesAndPagination(vehicles=db_vehicles, pagination=Pagination(skip=skip, limit=limit, total=total))
+
+
+@router.get("/retrieve_vehicles/", response_model=VehicleTablesAndPagination)
+def retrieve_vehicles(
+    name_match: str | None = Query(None),
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> VehicleTablesAndPagination:
+    with managed_db_session(db):
+        query_stmt = db.query(VehicleTable).where(VehicleTable.expired_at.is_(None))
+        if name_match:
+            query_stmt = query_stmt.where(
+                VehicleTable.name.ilike(f"%{escape_sql_like(name_match)}%", escape="\\"),
+            )
+
+        total = query_stmt.count()
+        db_vehicles = query_stmt.order_by(VehicleTable.sqn.asc()).offset(skip).limit(limit).all()
+
+    return VehicleTablesAndPagination(vehicles=db_vehicles, pagination=Pagination(skip=skip, limit=limit, total=total))
+
+
+class SensorTablesAndPagination(pdt.BaseModel):
+    sensors: list[SensorTable]
+    pagination: Pagination
+
+
+@router.get("/query_sensors/", response_model=SensorTablesAndPagination)
+def query_sensors(
+    effective_at: datetime.datetime = Query(),
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTablesAndPagination:
+    with managed_db_session(db):
+        query_stmt = (
+            db
+            .query(SensorTable)
+            .where(SensorTable.updated_at <= effective_at,
+                   sa.or_(SensorTable.expired_at.is_(None), SensorTable.expired_at > effective_at))
+        )
+
+        total = query_stmt.count()
+        db_sensors = query_stmt.order_by(SensorTable.sqn.asc()).offset(skip).limit(limit).all()
+
+    return SensorTablesAndPagination(sensors=db_sensors, pagination=Pagination(skip=skip, limit=limit, total=total))
+
+
+@router.get("/retrieve_sensors/", response_model=SensorTablesAndPagination)
+def retrieve_sensors(
+    serial_number_match: str | None = Query(None),
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> SensorTablesAndPagination:
+    with managed_db_session(db):
+        query_stmt = db.query(SensorTable).where(SensorTable.expired_at.is_(None))
+        if serial_number_match:
+            query_stmt = query_stmt.where(
+                SensorTable.serial_number.ilike(f"%{escape_sql_like(serial_number_match)}%", escape="\\"),
+            )
+
+        total = query_stmt.count()
+        db_sensors = query_stmt.order_by(SensorTable.sqn.asc()).offset(skip).limit(limit).all()
+
+    return SensorTablesAndPagination(sensors=db_sensors, pagination=Pagination(skip=skip, limit=limit, total=total))
+
+
+class BagTablesAndPagination(pdt.BaseModel):
+    bags: list[BagTable]
+    pagination: Pagination
+
+
+@router.get("/query_bags/", response_model=BagTablesAndPagination)
+def query_bags(
+    effective_at: datetime.datetime = Query(),
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> BagTablesAndPagination:
+    with managed_db_session(db):
+        query_stmt = (
+            db
+            .query(BagTable)
+            .where(BagTable.updated_at <= effective_at,
+                   sa.or_(BagTable.expired_at.is_(None), BagTable.expired_at > effective_at))
+        )
+
+        total = query_stmt.count()
+        db_bags = query_stmt.order_by(BagTable.sqn.asc()).offset(skip).limit(limit).all()
+
+    return BagTablesAndPagination(bags=db_bags, pagination=Pagination(skip=skip, limit=limit, total=total))
+
+
+@router.get("/retrieve_bags/", response_model=BagTablesAndPagination)
+def retrieve_bags(
+    begin_at: datetime.datetime | None = Query(None),
+    end_at: datetime.datetime | None = Query(None),
+    vehicle_names: list[str] | None = Query(None),
+    name_match: str | None = Query(None),
+    skip: int = Query(0),
+    limit: int = Query(100),
+    db: sa_orm.Session = Depends(make_session),
+) -> BagTablesAndPagination:
+    with managed_db_session(db):
+        query_stmt = db.query(BagTable).where(BagTable.expired_at.is_(None))
+        if begin_at is not None:
+            query_stmt = query_stmt.where(BagTable.begin_at >= begin_at)
+        if end_at is not None:
+            query_stmt = query_stmt.where(BagTable.end_at < end_at)
+        if vehicle_names:
+            query_stmt = query_stmt.where(BagTable.vehicle_name.in_(vehicle_names))
+        if name_match:
+            query_stmt = query_stmt.where(BagTable.name.ilike(f"%{escape_sql_like(name_match)}%", escape="\\"))
+
+        total = query_stmt.count()
+        db_bags = query_stmt.order_by(BagTable.sqn.asc()).offset(skip).limit(limit).all()
+
+    return BagTablesAndPagination(bags=db_bags, pagination=Pagination(skip=skip, limit=limit, total=total))
+
+
+@router.get("/query_bag/", response_model=BagTable)
+def query_bag(
+    name: str | None = Query(None),
+    db: sa_orm.Session = Depends(make_session),
+) -> BagTable:
+    with managed_db_session(db):
+        query_stmt = db.query(BagTable).where(BagTable.expired_at.is_(None))
+        if name is not None:
+            query_stmt = query_stmt.where(BagTable.name == name)
+        db_bag = query_stmt.one_or_none()
+        if db_bag is None:
+            raise sa_exc.NoResultFound(f"'{model_name_of(BagTable)}' with name '{name}' not found")
+
+    return db_bag