monkeybrain-runtime 1.0.0__py3-none-any.whl

services/facilities/routers/plant.py

@@ -0,0 +1,203 @@
+import re
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.facilities.helpers import plants as crud
+from services.facilities.helpers import lines as line_crud
+from services.facilities.helpers import stages as stage_crud
+from services.assets.helpers import machines as machine_crud
+from services.assets.helpers import equipment as equipment_crud
+
+from services.facilities.models.industrialPlant import (
+    IndustrialPlantCreate,
+    IndustrialPlantUpdate,
+    IndustrialPlantResponse,
+    PaginatedPlantResponse,
+)
+from services.facilities.models.industrialLine import IndustrialLineResponse
+from services.facilities.models.stages import IndustrialStageResponse
+from services.assets.models.machines import PharmaceuticalMachineResponse
+from services.assets.models.equipment import PharmaceuticalEquipmentResponse
+
+router = APIRouter()
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+@router.get("/", response_model=PaginatedPlantResponse)
+async def list_plants(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1),
+    status: Optional[str] = Query(None),
+    plant_type: Optional[str] = Query(None, alias="type"),
+    country: Optional[str] = Query(None),
+    timezone: Optional[str] = Query(None),
+    manager: Optional[str] = Query(None),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-plant")),
+):
+    plants, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+        status=status,
+        plant_type=plant_type,
+        country=country,
+        timezone=timezone,
+        manager=manager,
+    )
+    return PaginatedPlantResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=plants,
+    )
+
+
+# ── Get One ───────────────────────────────────────────────────────────────────
+
+@router.get("/{plant_id}/lines", response_model=list[IndustrialLineResponse])
+async def list_plant_lines(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-lines")),
+):
+    record = await crud.get_by_id(db, plant_id)
+    if not record:
+        record = await db["industrial_plants"].find_one(
+            {"name": {"$regex": f"^{re.escape(plant_id)}$", "$options": "i"}},
+        )
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plant '{plant_id}' not found",
+        )
+    return await line_crud.get_by_plant(db, str(record.get("id") or plant_id))
+
+
+@router.get("/{plant_id}/stages", response_model=list[IndustrialStageResponse])
+async def list_plant_stages(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-stages")),
+):
+    record = await _resolve_plant(db, plant_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plant '{plant_id}' not found",
+        )
+    return await stage_crud.get_by_plant(db, str(record.get("id") or plant_id))
+
+
+@router.get("/{plant_id}/machines", response_model=list[PharmaceuticalMachineResponse])
+async def list_plant_machines(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-machines")),
+):
+    record = await _resolve_plant(db, plant_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plant '{plant_id}' not found",
+        )
+    return await machine_crud.get_by_plant(db, str(record.get("id") or plant_id))
+
+
+@router.get("/{plant_id}/equipment", response_model=list[PharmaceuticalEquipmentResponse])
+async def list_plant_equipment(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-equipment")),
+):
+    record = await _resolve_plant(db, plant_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plant '{plant_id}' not found",
+        )
+    return await equipment_crud.get_by_plant(db, str(record.get("id") or plant_id))
+
+
+@router.get("/{plant_id}", response_model=IndustrialPlantResponse)
+async def get_plant(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-plant")),
+):
+    record = await crud.get_by_id(db, plant_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plant '{plant_id}' not found",
+        )
+    return record
+
+
+async def _resolve_plant(db: AsyncIOMotorDatabase, plant_id: str) -> dict | None:
+    record = await crud.get_by_id(db, plant_id)
+    if record:
+        return record
+    return await db["industrial_plants"].find_one(
+        {"name": {"$regex": f"^{re.escape(plant_id)}$", "$options": "i"}},
+    )
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=IndustrialPlantResponse, status_code=status.HTTP_201_CREATED)
+async def create_plant(
+    data: IndustrialPlantCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-plant")),
+):
+    if await crud.get_by_id(db, data.id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Plant '{data.id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{plant_id}", response_model=IndustrialPlantResponse)
+async def update_plant(
+    plant_id: str,
+    data: IndustrialPlantUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-plant")),
+):
+    updated = await crud.update(db, plant_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plant '{plant_id}' not found",
+        )
+    return updated
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{plant_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_plant(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-plant")),
+):
+    if not await crud.delete(db, plant_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plant '{plant_id}' not found",
+        )
+
+
+# ── Future Extensions ─────────────────────────────────────────────────────────
+
+# TODO: GET /api/v1/plants/{plant_id}/lines
+# TODO: GET /api/v1/plants/{plant_id}/machines
+# TODO: GET /api/v1/plants/{plant_id}/analytics

services/facilities/routers/rooms.py

@@ -0,0 +1,81 @@
+"""Router for rooms — queries plant_locations where type=room."""
+
+from fastapi import APIRouter, Depends, Query, status, HTTPException
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.facilities.helpers.locations import get_all_locations, update_location, delete_location, get_location_by_id
+from services.facilities.models.locations import LocationCreate, LocationUpdate
+
+router = APIRouter()
+
+
+def _to_room(doc: dict, parent_loc_id_map: dict[str, str] | None = None) -> dict:
+    parent_id = doc.get("parent_id")
+    floor_id = parent_loc_id_map.get(parent_id, parent_id) if parent_loc_id_map else parent_id
+    return {
+        "room_id": doc.get("location_id") or doc.get("id"),
+        "floor_id": floor_id,
+        "name": doc.get("name", ""),
+    }
+
+
+@router.get("/")
+async def list_rooms(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(100, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-rooms")),
+):
+    locs, _ = await get_all_locations(db, page=page, page_size=page_size, location_type="room")
+
+    parent_ids = {loc.get("parent_id") for loc in locs if loc.get("parent_id")}
+    parent_loc_id_map: dict[str, str] = {}
+    for pid in parent_ids:
+        parent_loc = await get_location_by_id(db, pid)
+        if parent_loc:
+            parent_loc_id_map[pid] = parent_loc.get("location_id", pid)
+
+    return [_to_room(loc, parent_loc_id_map) for loc in locs]
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_room(
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-rooms")),
+):
+    from services.facilities.helpers.locations import create_location
+    loc_data = LocationCreate(
+        name=data["name"],
+        location_id=data.get("room_id") or data.get("name", "").upper().replace(" ", "-"),
+        type="room",
+        level=4,
+        path=data.get("path", data["name"]),
+        parent_id=data.get("floor_id"),
+    )
+    created = await create_location(db, loc_data)
+    return _to_room(created)
+
+
+@router.patch("/{room_id}")
+async def update_room(
+    room_id: str,
+    data: dict,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-rooms")),
+):
+    updated = await update_location(db, room_id, LocationUpdate(name=data.get("name")))
+    if not updated:
+        raise HTTPException(status_code=404, detail="Room not found")
+    return _to_room(updated)
+
+
+@router.delete("/{room_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_room(
+    room_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-rooms")),
+):
+    await delete_location(db, room_id)

services/facilities/routers/stages.py

@@ -0,0 +1,152 @@
+import re
+from fastapi import APIRouter, HTTPException, Depends, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import get_current_user, require_permission
+from services.facilities.helpers import stages as crud
+from services.facilities.helpers import workstation as workstation_crud
+
+from services.facilities.models.stages import (
+    IndustrialStageCreate,
+    IndustrialStageUpdate,
+    IndustrialStageResponse,
+    PaginatedStageResponse,
+)
+from services.facilities.models.workstation import WorkstationResponse
+
+router = APIRouter()
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+@router.get("/", response_model=PaginatedStageResponse)
+async def list_stages(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-stages")),  # ⚠️ stages tied to stages
+):
+    stages, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+    )
+    return PaginatedStageResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=stages,
+    )
+
+
+# ── Get by circuit ────────────────────────────────────────────────────────────
+
+@router.get("/by-circuit/{circuit_id}", response_model=list[IndustrialStageResponse])
+async def list_stages_by_circuit(
+    circuit_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-stages")),
+):
+    return await crud.get_by_circuit(db, circuit_id)
+
+
+@router.get("/by-line/{line_id}", response_model=list[IndustrialStageResponse])
+async def list_stages_by_line(
+    line_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-lines")),
+):
+    return await crud.get_by_line(db, line_id)
+
+
+@router.get("/by-plant/{plant_id}", response_model=list[IndustrialStageResponse])
+async def list_stages_by_plant(
+    plant_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-stages")),
+):
+    return await crud.get_by_plant(db, plant_id)
+
+
+@router.get("/{stage_id}/workstations", response_model=list[WorkstationResponse])
+async def list_stage_workstations(
+    stage_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    record = await crud.get_by_id(db, stage_id)
+    if not record:
+        record = await db["industrial_stages"].find_one({"name": {"$regex": f"^{re.escape(stage_id)}$", "$options": "i"}})
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Stage '{stage_id}' not found",
+        )
+    return await workstation_crud.get_by_stage_id(db, str(record.get("id") or stage_id))
+
+
+# ── Get one ───────────────────────────────────────────────────────────────────
+
+@router.get("/{stage_id}", response_model=IndustrialStageResponse)
+async def get_stage(
+    stage_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-stages")),
+):
+    record = await crud.get_by_id(db, stage_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Stage '{stage_id}' not found",
+        )
+    return record
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=IndustrialStageResponse, status_code=status.HTTP_201_CREATED)
+async def create_stage(
+    data: IndustrialStageCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-stages")),
+):
+    if await crud.get_by_id(db, data.id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Stage '{data.id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{stage_id}", response_model=IndustrialStageResponse)
+async def update_stage(
+    stage_id: str,
+    data: IndustrialStageUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-stages")),
+):
+    updated = await crud.update(db, stage_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Stage '{stage_id}' not found",
+        )
+    return updated
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{stage_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_stage(
+    stage_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-stages")),
+):
+    if not await crud.delete(db, stage_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Stage '{stage_id}' not found",
+        )

services/facilities/routers/workstation.py

@@ -0,0 +1,173 @@
+import re
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import get_current_user, require_permission
+from services.facilities.helpers import workstation as crud
+from services.assets.helpers import machines as machine_crud
+from services.assets.helpers import equipment as equipment_crud
+
+from services.facilities.models.workstation import (
+    WorkstationCreate,
+    WorkstationUpdate,
+    WorkstationResponse,
+    PaginatedWorkstationResponse,
+)
+from services.assets.models.machines import PharmaceuticalMachineResponse
+from services.assets.models.equipment import PharmaceuticalEquipmentResponse
+
+router = APIRouter()
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+@router.get("/", response_model=PaginatedWorkstationResponse)
+async def list_workstations(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    workstations, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+    )
+    return PaginatedWorkstationResponse(
+        total=total,
+        page=page,
+        page_size=page_size,
+        results=workstations,
+    )
+
+
+# ── Get by line ───────────────────────────────────────────────────────────────
+
+@router.get("/by-line/{line_id}", response_model=list[WorkstationResponse])
+async def list_workstations_by_line(
+    line_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    return await crud.get_by_line(db, line_id)
+
+@router.get("/by-stage/{stage_id}", response_model=list[WorkstationResponse])
+async def list_workstations_by_stage(
+    stage_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    return await crud.get_by_stage_id(db, stage_id)
+
+
+@router.get("/{workstation_id}/machines", response_model=list[PharmaceuticalMachineResponse])
+async def list_workstation_machines(
+    workstation_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    record = await crud.get_by_id(db, workstation_id)
+    if not record:
+        record = await db["workstations"].find_one({"name": {"$regex": f"^{re.escape(workstation_id)}$", "$options": "i"}})
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Workstation '{workstation_id}' not found",
+        )
+    return await machine_crud.get_by_workstation(db, str(record.get("id") or workstation_id))
+
+
+@router.get("/{workstation_id}/equipment", response_model=list[PharmaceuticalEquipmentResponse])
+async def list_workstation_equipment(
+    workstation_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    record = await crud.get_by_id(db, workstation_id)
+    if not record:
+        record = await db["workstations"].find_one({"name": {"$regex": f"^{re.escape(workstation_id)}$", "$options": "i"}})
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Workstation '{workstation_id}' not found",
+        )
+    return await equipment_crud.get_by_workstation_id(db, str(record.get("id") or workstation_id))
+
+# ── Get bottlenecks ───────────────────────────────────────────────────────────
+
+@router.get("/bottlenecks", response_model=list[WorkstationResponse])
+async def list_bottlenecks(
+    line_id: Optional[str] = Query(None, description="Optionally scope to a specific line"),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    return await crud.get_bottlenecks(db, line_id=line_id)
+
+
+# ── Get one ───────────────────────────────────────────────────────────────────
+
+@router.get("/{workstation_id}", response_model=WorkstationResponse)
+async def get_workstation(
+    workstation_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(get_current_user),
+):
+    record = await crud.get_by_id(db, workstation_id)
+    if not record:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Workstation '{workstation_id}' not found",
+        )
+    return record
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=WorkstationResponse, status_code=status.HTTP_201_CREATED)
+async def create_workstation(
+    data: WorkstationCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-workstation")),
+):
+    if await crud.get_by_id(db, data.id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Workstation '{data.id}' already exists",
+        )
+    return await crud.create(db, data)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{workstation_id}", response_model=WorkstationResponse)
+async def update_workstation(
+    workstation_id: str,
+    data: WorkstationUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-workstation")),
+):
+    updated = await crud.update(db, workstation_id, data)
+    if not updated:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Workstation '{workstation_id}' not found",
+        )
+    return updated
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{workstation_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_workstation(
+    workstation_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-workstation")),
+):
+    if not await crud.delete(db, workstation_id):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Workstation '{workstation_id}' not found",
+        )
+

services/file/backup.py

@@ -0,0 +1,71 @@
+import os
+import boto3
+from datetime import datetime, timedelta
+from botocore.exceptions import BotoCoreError, ClientError
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+AWS_REGION = os.getenv("AWS_REGION", "ap-south-1")
+SOURCE_BUCKET = os.getenv("AWS_S3_BUCKET")  # main bucket
+BACKUP_BUCKET = os.getenv("AWS_S3_BACKUP_BUCKET", SOURCE_BUCKET)  # can be same or different bucket
+BACKUP_PREFIX = os.getenv("AWS_S3_BACKUP_PREFIX", "backups/")
+
+# Initialize S3 client
+s3 = boto3.client(
+    "s3",
+    aws_access_key_id=AWS_ACCESS_KEY_ID,
+    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+    region_name=AWS_REGION,
+)
+
+def backup_and_delete(date_str: str = None):
+    """
+    Copies all files from uploads/{date}/ to backups/{date}/,
+    verifies copy, then deletes originals.
+    """
+    if not date_str:
+        # default to previous day's folder
+        date_str = (datetime.utcnow() - timedelta(days=1)).strftime("%Y-%m-%d")
+
+    source_prefix = f"uploads/{date_str}/"
+    backup_prefix = f"{BACKUP_PREFIX}{date_str}/"
+
+    print(f"🔍 Checking for files in: s3://{SOURCE_BUCKET}/{source_prefix}")
+
+    try:
+        response = s3.list_objects_v2(Bucket=SOURCE_BUCKET, Prefix=source_prefix)
+        if "Contents" not in response:
+            print(f"❌ No files found for {date_str}")
+            return
+
+        for obj in response["Contents"]:
+            key = obj["Key"]
+            dest_key = key.replace(source_prefix, backup_prefix, 1)
+
+            print(f"📦 Backing up: {key} → {dest_key}")
+            s3.copy_object(
+                Bucket=BACKUP_BUCKET,
+                CopySource={"Bucket": SOURCE_BUCKET, "Key": key},
+                Key=dest_key,
+            )
+
+        print(f"✅ Backup complete. Starting deletion of originals...")
+
+        # Delete all files from the source folder
+        delete_objects = {"Objects": [{"Key": obj["Key"]} for obj in response["Contents"]]}
+        s3.delete_objects(Bucket=SOURCE_BUCKET, Delete=delete_objects)
+
+        print(f"🧹 Deleted all files under {source_prefix}")
+        print(f"🎉 Backup and cleanup complete for {date_str}")
+
+    except (BotoCoreError, ClientError) as e:
+        print(f"❌ AWS error: {e}")
+    except Exception as e:
+        print(f"⚠️ Unexpected error: {e}")
+
+if __name__ == "__main__":
+    backup_and_delete()