⚡ Bolt: Optimize Image Pipeline and Upvote Operation#354
⚡ Bolt: Optimize Image Pipeline and Upvote Operation#354RohanExploit wants to merge 1 commit intomainfrom
Conversation
- Enhanced `process_uploaded_image` to return both `PIL.Image` and `bytes` in a single pass, eliminating redundant decode/encode cycles. - Refactored `process_and_detect` and detection endpoints to utilize the optimized image pipeline. - Optimized `upvote_issue` with an atomic UPDATE query and column projection to avoid full ORM object loading. - Implemented `blockchain-verify` endpoint to verify integrity seals of reports. - Reduced payload size for AI detection by ensuring all images are resized and stripped of EXIF before transmission. Co-authored-by: RohanExploit <178623867+RohanExploit@users.noreply.github.com>
|
👋 Jules, reporting for duty! I'm here to lend a hand with this pull request. When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down. I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job! For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with New to Jules? Learn more at jules.google/docs. For security, I will only act on instructions from the user who triggered this task. |
✅ Deploy Preview for fixmybharat canceled.
|
🙏 Thank you for your contribution, @RohanExploit!PR Details:
Quality Checklist:
Review Process:
Note: The maintainers will monitor code quality and ensure the overall project flow isn't broken. |
📝 WalkthroughWalkthroughThis PR refactors image processing pipelines to return tuples of (PIL.Image, bytes) instead of BytesIO objects, adds blockchain verification for issue integrity validation with a new endpoint and schema, updates routers to use centralized image processing, and optimizes the upvote mutation with atomic updates. Changes
Sequence DiagramsequenceDiagram
actor Client
participant API as verify_issue_blockchain<br/>(Endpoint)
participant DB as Database
participant Hash as Hash Calculator
participant Schema as BlockchainVerifyResponse
Client->>API: GET /issues/{issue_id}/verify-blockchain
API->>DB: Fetch issue & predecessor hash
DB-->>API: Issue content + previous_hash
API->>Hash: Calculate SHA-256(content + previous_hash)
Hash-->>API: calculated_hash
API->>Hash: Compare calculated_hash vs integrity_hash
Hash-->>API: is_valid (boolean)
API->>Schema: Build response
Schema-->>API: BlockchainVerifyResponse object
API-->>Client: {issue_id, is_valid, integrity_hash,<br/>calculated_hash, previous_hash}
Estimated code review effort🎯 3 (Moderate) | ⏱️ ~25 minutes Possibly related PRs
Suggested labels
Poem
🚥 Pre-merge checks | ✅ 2 | ❌ 1❌ Failed checks (1 warning)
✅ Passed checks (2 passed)
✏️ Tip: You can configure your own custom pre-merge checks in the settings. ✨ Finishing touches
🧪 Generate unit tests (beta)
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
There was a problem hiding this comment.
Pull request overview
This PR optimizes image handling across the backend by switching to a single-pass image processing pipeline that returns both a PIL image and optimized bytes, refactors issue upvoting to use an atomic SQL update without loading full models, and adds an endpoint to verify an issue’s blockchain-style integrity hash.
Changes:
- Updated image processing utilities and call sites to avoid redundant decode/encode cycles and consistently produce optimized image bytes.
- Optimized
/api/issues/{issue_id}/voteto perform an atomic counter increment viaUPDATE, then fetch only required columns. - Added
/api/issues/{issue_id}/blockchain-verifyendpoint and corresponding response schema.
Reviewed changes
Copilot reviewed 7 out of 7 changed files in this pull request and generated 6 comments.
Show a summary per file
| File | Description |
|---|---|
backend/utils.py |
Changes image processing to return (PIL.Image, bytes) and updates saving/processing helpers. |
backend/routers/issues.py |
Uses new image pipeline, optimizes upvote query, and adds blockchain verification endpoint/response. |
backend/routers/detection.py |
Switches several detection endpoints to use process_uploaded_image for optimized bytes. |
backend/hf_api_service.py |
Expands image byte preparation helper to accept BytesIO in addition to bytes/PIL. |
backend/schemas.py |
Adds BlockchainVerifyResponse schema. |
tests/test_issue_creation.py |
Updates mocks to match new (PIL.Image, bytes) return contract. |
tests/test_verification_feature.py |
Updates mocks to patch process_uploaded_image and return (PIL.Image, bytes). |
Comments suppressed due to low confidence (1)
backend/routers/issues.py:25
validate_uploaded_fileis imported frombackend.utilsbut is no longer referenced in this module after switching verification and upload paths toprocess_uploaded_image. Consider removing the unused import to avoid lint/type-check noise.
from backend.utils import (
check_upload_limits, validate_uploaded_file, save_file_blocking, save_issue_db,
process_uploaded_image, save_processed_image,
UPLOAD_LIMIT_PER_USER, UPLOAD_LIMIT_PER_IP
)
💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.
| @router.get("/api/issues/{issue_id}/blockchain-verify", response_model=BlockchainVerifyResponse) | ||
| async def verify_issue_blockchain(issue_id: int, db: Session = Depends(get_db)): | ||
| """ | ||
| Blockchain Verification: Verifies the integrity seal of a report. | ||
| Checks if the hash of the current issue matches its content and the previous hash. | ||
| """ | ||
| # Fetch current issue and its predecessor's hash | ||
| issue = await run_in_threadpool(lambda: db.query(Issue).filter(Issue.id == issue_id).first()) | ||
| if not issue: | ||
| raise HTTPException(status_code=404, detail="Issue not found") | ||
|
|
||
| # Get predecessor hash | ||
| prev_issue = await run_in_threadpool( | ||
| lambda: db.query(Issue.integrity_hash).filter(Issue.id < issue_id).order_by(Issue.id.desc()).first() | ||
| ) | ||
| prev_hash = prev_issue[0] if prev_issue and prev_issue[0] else "" | ||
|
|
||
| # Recalculate hash | ||
| hash_content = f"{issue.description}|{issue.category}|{prev_hash}" | ||
| calculated_hash = hashlib.sha256(hash_content.encode()).hexdigest() | ||
|
|
||
| is_valid = (calculated_hash == issue.integrity_hash) | ||
|
|
||
| return BlockchainVerifyResponse( | ||
| issue_id=issue.id, | ||
| is_valid=is_valid, | ||
| integrity_hash=issue.integrity_hash or "", | ||
| calculated_hash=calculated_hash, | ||
| previous_hash=prev_hash | ||
| ) |
There was a problem hiding this comment.
New public endpoint /api/issues/{issue_id}/blockchain-verify is added without any corresponding test coverage. Please add at least a basic test that creates an issue with an integrity hash and asserts the endpoint returns is_valid=True (and a negative case where the issue content or predecessor hash is changed).
| @@ -36,7 +36,8 @@ def test_create_issue(): | |||
| patch("backend.tasks.generate_action_plan", new_callable=AsyncMock) as mock_plan: | |||
|
|
|||
| import io | |||
There was a problem hiding this comment.
import io is now unused after switching the mocked process_uploaded_image return value to (PIL.Image, bytes). Consider removing it to keep the test clean and avoid lint noise.
| import io |
| fmt = img.format or 'JPEG' | ||
| img_no_exif.save(output, format=fmt, quality=85) |
There was a problem hiding this comment.
process_uploaded_image_sync always passes quality=85 to PIL.Image.save() while preserving the original format. For formats like PNG/GIF/TIFF this parameter is not supported and can raise at runtime, despite those MIME types being allowed. Consider only passing JPEG/WebP-specific kwargs when fmt is JPEG/WebP, and using appropriate options for PNG (e.g., optimize/compress_level) or omitting quality entirely for non-lossy formats.
| fmt = img.format or 'JPEG' | |
| img_no_exif.save(output, format=fmt, quality=85) | |
| fmt = (img.format or 'JPEG').upper() | |
| save_kwargs = {} | |
| if fmt in ('JPEG', 'JPG', 'WEBP'): | |
| # Use quality setting for lossy formats | |
| save_kwargs['quality'] = 85 | |
| elif fmt == 'PNG': | |
| # Use appropriate options for PNG (lossless) | |
| save_kwargs['optimize'] = True | |
| save_kwargs['compress_level'] = 6 | |
| img_no_exif.save(output, format=fmt, **save_kwargs) |
| # Strip EXIF | ||
| img_no_exif = Image.new(img.mode, img.size) | ||
| img_no_exif.paste(img) | ||
|
|
||
| # Save to BytesIO | ||
| # Save to bytes | ||
| output = io.BytesIO() | ||
| # Preserve format or default to JPEG | ||
| fmt = img.format or 'JPEG' | ||
| img_no_exif.save(output, format=fmt, quality=85) | ||
| output.seek(0) | ||
| image_bytes = output.getvalue() | ||
|
|
||
| return output | ||
| return img_no_exif, image_bytes |
There was a problem hiding this comment.
process_uploaded_image_sync returns a newly created img_no_exif, but this image typically has format=None (since it’s created via Image.new). Callers that later serialize the PIL image (e.g., HF helpers defaulting based on image.format) can pick an incorrect format and fail (notably RGBA -> default JPEG). Consider returning/propagating the effective fmt, setting img_no_exif.format, or converting to an appropriate mode/format before returning.
| # Use JPEG as default if format is missing (e.g. for newly created images) | ||
| fmt = image.format if image.format else 'JPEG' |
There was a problem hiding this comment.
_prepare_image_bytes defaults to JPEG when image.format is missing. This can break for non-JPEG-compatible modes (e.g., RGBA images can’t be saved as JPEG). Consider choosing a default format based on image.mode (e.g., PNG for RGBA/P) or converting to RGB when defaulting to JPEG.
| # Use JPEG as default if format is missing (e.g. for newly created images) | |
| fmt = image.format if image.format else 'JPEG' | |
| # Determine format, taking image.mode into account when format is missing. | |
| fmt = image.format | |
| if not fmt: | |
| # For images with alpha or palette, default to PNG to avoid JPEG incompatibilities. | |
| if image.mode in ("RGBA", "LA", "P"): | |
| fmt = "PNG" | |
| else: | |
| # Preserve existing behavior for typical modes (e.g., RGB, L) by defaulting to JPEG. | |
| fmt = "JPEG" | |
| # If saving as JPEG, ensure the image is in a JPEG-compatible mode. | |
| if fmt.upper() in ("JPEG", "JPG") and image.mode not in ("RGB", "L"): | |
| image = image.convert("RGB") |
| # Get predecessor hash | ||
| prev_issue = await run_in_threadpool( | ||
| lambda: db.query(Issue.integrity_hash).filter(Issue.id < issue_id).order_by(Issue.id.desc()).first() | ||
| ) | ||
| prev_hash = prev_issue[0] if prev_issue and prev_issue[0] else "" | ||
|
|
||
| # Recalculate hash | ||
| hash_content = f"{issue.description}|{issue.category}|{prev_hash}" | ||
| calculated_hash = hashlib.sha256(hash_content.encode()).hexdigest() | ||
|
|
||
| is_valid = (calculated_hash == issue.integrity_hash) |
There was a problem hiding this comment.
The blockchain verification logic assumes the “previous hash” is from the issue with the greatest id less than issue_id, but the hash creation during issue creation uses “latest issue at creation time”. Under concurrent issue creation, multiple issues can compute the same prev_hash, and later verification for one branch will fail. To make verification stable, persist the exact previous hash/previous issue id used at creation time (or compute within a serialized transaction/lock) and verify against that stored predecessor.
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 3
🤖 Fix all issues with AI agents
In `@backend/hf_api_service.py`:
- Around line 47-59: In _prepare_image_bytes, handle images with alpha channels
to avoid raising when saving as JPEG: detect when image.format is None and
image.mode contains an alpha channel (e.g., 'RGBA', 'LA' or 'P' with
transparency) and either choose 'PNG' as the format or convert the image to
'RGB' before saving as 'JPEG'; update the logic around fmt = image.format if
image.format else 'JPEG' and the image.save call so that images with
transparency are saved as PNG (or are converted to RGB when you explicitly want
JPEG), ensuring you call image.convert('RGB') when converting and then save to
img_byte_arr.getvalue() as before.
In `@backend/routers/issues.py`:
- Around line 614-644: The current verify_issue_blockchain endpoint relies on
querying the "previous" issue by ID (Issue.id < issue_id ordered desc) which
breaks if issues are deleted or created concurrently; change the design to use
an explicit previous pointer and optimize the query: add a previous_issue_id
column/field to the Issue model (and populate it at creation time), update
verify_issue_blockchain to load only the required columns (description,
category, integrity_hash, previous_issue_id) using a projection via
db.query(...) and then fetch the predecessor by previous_issue_id
(db.query(Issue.description, Issue.category,
Issue.integrity_hash).filter(Issue.id == issue.previous_issue_id).first())
instead of relying on ID ordering; keep the same hash recomputation logic
(hash_content = f"{description}|{category}|{previous_hash}") and compare to
issue.integrity_hash, and ensure you're still using run_in_threadpool wrappers
for the DB calls.
In `@backend/utils.py`:
- Around line 183-190: The save path fails for RGBA images because fmt =
img.format or 'JPEG' will try to write RGBA as JPEG; update the save logic in
process_uploaded_image (and mirror in _validate_uploaded_file_sync) to handle
alpha modes: either choose 'PNG' when img_no_exif.mode contains an alpha channel
(e.g., 'RGBA' or 'LA') or convert img_no_exif = img_no_exif.convert('RGB')
before saving if you must keep JPEG; ensure the fmt selection and/or conversion
happens just before img_no_exif.save(output, format=fmt, quality=85) so
image_bytes is generated without raising OSError.
🧹 Nitpick comments (3)
backend/routers/issues.py (1)
248-274: Upvote atomicity is solid, but the endpoint is not concurrency-safe for the read-after-write.The atomic
UPDATEwithfunc.coalesce(lines 258-260) is a good improvement. However, betweendb.commit()(line 265) and the subsequentSELECT(line 268), another concurrent request could increment the counter, so the returnedupvotesvalue may not reflect this request's increment alone. This is typically acceptable for display purposes, but worth noting for correctness.Also, this is a synchronous endpoint (
def) with DB I/O — consistent with the existing pattern in this file, but it will block the async event loop thread. Consider making itasyncwithrun_in_threadpoolif DB latency is a concern (can be deferred).backend/utils.py (2)
141-203: Significant code duplication betweenprocess_uploaded_image_syncand_validate_uploaded_file_sync.Both functions perform nearly identical operations: size check, MIME validation, PIL open, resize. The main differences are EXIF stripping and the return type. Consider extracting shared validation/resize logic into a private helper and having both functions call it. This would reduce the maintenance burden and avoid divergent bug fixes.
Also applies to: 56-133
205-210: Consider adding a return type annotation.The async wrapper lacks a return type hint. Adding
-> tuple[Image.Image, bytes](orTuplefor older Python) would improve API clarity and catch misuse at type-check time.♻️ Suggested annotation
-async def process_uploaded_image(file: UploadFile): +async def process_uploaded_image(file: UploadFile) -> tuple[Image.Image, bytes]:
| def _prepare_image_bytes(image: Union[Image.Image, bytes, io.BytesIO]) -> bytes: | ||
| """Helper to ensure image is in bytes format for HF API.""" | ||
| if isinstance(image, bytes): | ||
| return image | ||
| if isinstance(image, io.BytesIO): | ||
| return image.getvalue() | ||
|
|
||
| # It's a PIL Image | ||
| img_byte_arr = io.BytesIO() | ||
| # Use JPEG as default if format is missing (e.g. for newly created images) | ||
| fmt = image.format if image.format else 'JPEG' | ||
| image.save(img_byte_arr, format=fmt) | ||
| return img_byte_arr.getvalue() |
There was a problem hiding this comment.
Minor edge case: saving RGBA image as JPEG will raise an error.
When image.format is None and image.mode is 'RGBA' (e.g., from a PNG with transparency), image.save(..., format='JPEG') will raise an exception since JPEG doesn't support alpha. With the new pipeline this path is rarely hit (callers now pass bytes directly), but it could still be triggered by internal callers passing a PIL Image without a format set.
🛡️ Suggested defensive fix
# It's a PIL Image
img_byte_arr = io.BytesIO()
# Use JPEG as default if format is missing (e.g. for newly created images)
- fmt = image.format if image.format else 'JPEG'
+ fmt = image.format if image.format else ('PNG' if image.mode == 'RGBA' else 'JPEG')
image.save(img_byte_arr, format=fmt)
return img_byte_arr.getvalue()🤖 Prompt for AI Agents
In `@backend/hf_api_service.py` around lines 47 - 59, In _prepare_image_bytes,
handle images with alpha channels to avoid raising when saving as JPEG: detect
when image.format is None and image.mode contains an alpha channel (e.g.,
'RGBA', 'LA' or 'P' with transparency) and either choose 'PNG' as the format or
convert the image to 'RGB' before saving as 'JPEG'; update the logic around fmt
= image.format if image.format else 'JPEG' and the image.save call so that
images with transparency are saved as PNG (or are converted to RGB when you
explicitly want JPEG), ensuring you call image.convert('RGB') when converting
and then save to img_byte_arr.getvalue() as before.
|
|
||
| @router.get("/api/issues/{issue_id}/blockchain-verify", response_model=BlockchainVerifyResponse) | ||
| async def verify_issue_blockchain(issue_id: int, db: Session = Depends(get_db)): | ||
| """ | ||
| Blockchain Verification: Verifies the integrity seal of a report. | ||
| Checks if the hash of the current issue matches its content and the previous hash. | ||
| """ | ||
| # Fetch current issue and its predecessor's hash | ||
| issue = await run_in_threadpool(lambda: db.query(Issue).filter(Issue.id == issue_id).first()) | ||
| if not issue: | ||
| raise HTTPException(status_code=404, detail="Issue not found") | ||
|
|
||
| # Get predecessor hash | ||
| prev_issue = await run_in_threadpool( | ||
| lambda: db.query(Issue.integrity_hash).filter(Issue.id < issue_id).order_by(Issue.id.desc()).first() | ||
| ) | ||
| prev_hash = prev_issue[0] if prev_issue and prev_issue[0] else "" | ||
|
|
||
| # Recalculate hash | ||
| hash_content = f"{issue.description}|{issue.category}|{prev_hash}" | ||
| calculated_hash = hashlib.sha256(hash_content.encode()).hexdigest() | ||
|
|
||
| is_valid = (calculated_hash == issue.integrity_hash) | ||
|
|
||
| return BlockchainVerifyResponse( | ||
| issue_id=issue.id, | ||
| is_valid=is_valid, | ||
| integrity_hash=issue.integrity_hash or "", | ||
| calculated_hash=calculated_hash, | ||
| previous_hash=prev_hash | ||
| ) |
There was a problem hiding this comment.
Blockchain chain verification can break if issues are deleted or created concurrently.
The predecessor lookup (Issue.id < issue_id, ordered desc, line 628) assumes the issue with the next-lower ID was the predecessor at creation time. This holds only if:
- No issues are ever deleted.
- Issues are created strictly sequentially (no concurrent inserts).
If either assumption is violated, the recalculated hash won't match, producing a false negative (is_valid=False). This is a design limitation of the simple ID-based chaining. Consider storing previous_issue_id explicitly on the Issue model to make the chain traversal deterministic.
Additionally, the endpoint fetches the full Issue model (line 622) but only needs description, category, and integrity_hash. Column projection would be consistent with the optimization theme of this PR.
♻️ Optional: use column projection
- issue = await run_in_threadpool(lambda: db.query(Issue).filter(Issue.id == issue_id).first())
+ issue = await run_in_threadpool(
+ lambda: db.query(Issue.id, Issue.description, Issue.category, Issue.integrity_hash)
+ .filter(Issue.id == issue_id).first()
+ )🧰 Tools
🪛 Ruff (0.14.14)
[warning] 616-616: Do not perform function call Depends in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
(B008)
🤖 Prompt for AI Agents
In `@backend/routers/issues.py` around lines 614 - 644, The current
verify_issue_blockchain endpoint relies on querying the "previous" issue by ID
(Issue.id < issue_id ordered desc) which breaks if issues are deleted or created
concurrently; change the design to use an explicit previous pointer and optimize
the query: add a previous_issue_id column/field to the Issue model (and populate
it at creation time), update verify_issue_blockchain to load only the required
columns (description, category, integrity_hash, previous_issue_id) using a
projection via db.query(...) and then fetch the predecessor by previous_issue_id
(db.query(Issue.description, Issue.category,
Issue.integrity_hash).filter(Issue.id == issue.previous_issue_id).first())
instead of relying on ID ordering; keep the same hash recomputation logic
(hash_content = f"{description}|{category}|{previous_hash}") and compare to
issue.integrity_hash, and ensure you're still using run_in_threadpool wrappers
for the DB calls.
| # Save to bytes | ||
| output = io.BytesIO() | ||
| # Preserve format or default to JPEG | ||
| fmt = img.format or 'JPEG' | ||
| img_no_exif.save(output, format=fmt, quality=85) | ||
| output.seek(0) | ||
| image_bytes = output.getvalue() | ||
|
|
||
| return output | ||
| return img_no_exif, image_bytes |
There was a problem hiding this comment.
Bug: Saving RGBA images as JPEG will raise OSError after resize.
After img.resize(...) (line 177), the returned Image object has format=None. The fallback on line 186 defaults to 'JPEG', but JPEG doesn't support the RGBA mode (e.g., from PNG images with transparency). This will raise OSError: cannot write mode RGBA as JPEG for any RGBA image larger than 1024px.
The same pattern exists in _validate_uploaded_file_sync (line 104), but since process_uploaded_image_sync is now the primary pipeline, this is the more impactful location.
🐛 Proposed fix
# Save to bytes
output = io.BytesIO()
# Preserve format or default to JPEG
- fmt = img.format or 'JPEG'
+ fmt = img.format or ('PNG' if img_no_exif.mode == 'RGBA' else 'JPEG')
+ if fmt == 'JPEG' and img_no_exif.mode == 'RGBA':
+ img_no_exif = img_no_exif.convert('RGB')
img_no_exif.save(output, format=fmt, quality=85)
image_bytes = output.getvalue()📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| # Save to bytes | |
| output = io.BytesIO() | |
| # Preserve format or default to JPEG | |
| fmt = img.format or 'JPEG' | |
| img_no_exif.save(output, format=fmt, quality=85) | |
| output.seek(0) | |
| image_bytes = output.getvalue() | |
| return output | |
| return img_no_exif, image_bytes | |
| # Save to bytes | |
| output = io.BytesIO() | |
| # Preserve format or default to JPEG | |
| fmt = img.format or ('PNG' if img_no_exif.mode == 'RGBA' else 'JPEG') | |
| if fmt == 'JPEG' and img_no_exif.mode == 'RGBA': | |
| img_no_exif = img_no_exif.convert('RGB') | |
| img_no_exif.save(output, format=fmt, quality=85) | |
| image_bytes = output.getvalue() | |
| return img_no_exif, image_bytes |
🧰 Tools
🪛 Ruff (0.14.14)
[warning] 190-190: Consider moving this statement to an else block
(TRY300)
🤖 Prompt for AI Agents
In `@backend/utils.py` around lines 183 - 190, The save path fails for RGBA images
because fmt = img.format or 'JPEG' will try to write RGBA as JPEG; update the
save logic in process_uploaded_image (and mirror in
_validate_uploaded_file_sync) to handle alpha modes: either choose 'PNG' when
img_no_exif.mode contains an alpha channel (e.g., 'RGBA' or 'LA') or convert
img_no_exif = img_no_exif.convert('RGB') before saving if you must keep JPEG;
ensure the fmt selection and/or conversion happens just before
img_no_exif.save(output, format=fmt, quality=85) so image_bytes is generated
without raising OSError.
1 participant
💡 What: Optimized the core image processing pipeline and the issue upvote operation. Implemented a blockchain verification endpoint.
🎯 Why: Redundant image decode/encode cycles were causing unnecessary CPU and I/O overhead. Loading full SQLAlchemy models for simple counter increments was inefficient for memory and database performance.
📊 Impact:
🔬 Measurement: Verified using reproduction scripts and existing test suite. Confirmed that redundant operations are eliminated and database queries are more focused.
PR created automatically by Jules for task 1580436240060751091 started by @RohanExploit
Summary by CodeRabbit
Release Notes
New Features
Improvements