velocity-python 0.0.211__tar.gz → 0.0.213__tar.gz

{velocity_python-0.0.211 → velocity_python-0.0.213}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.211
+Version: 0.0.213
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.211 → velocity_python-0.0.213}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.211"
+version = "0.0.213"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.211 → velocity_python-0.0.213}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.211"
+__version__ = version = "0.0.213"
 
 from . import aws
 from . import db

{velocity_python-0.0.211 → velocity_python-0.0.213}/src/velocity/app/tests/test_spreadsheet_functions.py

@@ -2,6 +2,7 @@ import unittest
 import base64
 from io import BytesIO
 from openpyxl import load_workbook
+from openpyxl.cell.cell import MergedCell
 from velocity.misc.export import (
     extract,
     autosize_columns,
@@ -73,9 +74,9 @@ class TestSpreadsheetFunctions(unittest.TestCase):
 
         # Verify merged cells and styles
         self.assertTrue(worksheet.merged_cells.ranges)
-        self.assertEqual(str(worksheet.merged_cells.ranges[0]), "A1:B1")
+        self.assertIn("A1:B1", {str(cell_range) for cell_range in worksheet.merged_cells.ranges})
         self.assertEqual(worksheet["A1"].style, "col_header")
-        self.assertEqual(worksheet["B1"].style, "col_header")
+        self.assertIsInstance(worksheet["B1"], MergedCell)
 
     def test_create_spreadsheet_with_freeze_panes_and_dimensions(self):
         """Test creating a spreadsheet with freeze panes and custom row/column dimensions."""
@@ -97,6 +98,35 @@ class TestSpreadsheetFunctions(unittest.TestCase):
         self.assertEqual(worksheet.column_dimensions["A"].width, 20)
         self.assertEqual(worksheet.column_dimensions["B"].width, 30)
 
+    def test_create_spreadsheet_autosizes_boolean_values(self):
+        """Test that autosizing accounts for displayed boolean values."""
+        buffer = BytesIO()
+
+        create_spreadsheet([""], [[False]], buffer)
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        self.assertFalse(worksheet["A2"].value)
+        self.assertAlmostEqual(worksheet.column_dimensions["A"].width, 8.4, places=1)
+
+    def test_create_spreadsheet_autosizes_formatted_numbers(self):
+        """Test that autosizing uses formatted number display width."""
+        buffer = BytesIO()
+
+        create_spreadsheet(
+            ["Amt"],
+            [[1234]],
+            buffer,
+            formats={"A2": "$#,##0.00"},
+        )
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        self.assertEqual(worksheet["A2"].number_format, "$#,##0.00")
+        self.assertAlmostEqual(worksheet.column_dimensions["A"].width, 13.2, places=1)
+
     def test_get_downloadable_spreadsheet(self):
         """Test generating a downloadable spreadsheet encoded in base64."""
         headers = ["Header1", "Header2"]

{velocity_python-0.0.211 → velocity_python-0.0.213}/src/velocity/aws/handlers/base_handler.py

@@ -288,12 +288,49 @@ class BaseHandler:
                             "onerror_exc": on_error_exc.__class__.__name__,
                         },
                     )
-                    return
-                raise
-        else:
-            # Re-raise if no error handler is defined
+                else:
+                    raise
+
+        if self._set_unhandled_error_response(local_context):
+            return
+
+        if not hasattr(self, "onError"):
+            # Non-HTTP contexts without a custom error hook should still fail fast.
             raise exception
 
+    def _set_unhandled_error_response(self, local_context) -> bool:
+        response_getter = getattr(local_context, "response", None)
+        if not callable(response_getter):
+            return False
+
+        response = response_getter()
+        if response is None:
+            return False
+
+        reference_id = getattr(self.aws_context, "aws_request_id", None)
+        title = "Request Failed"
+        message = "Something went wrong while processing your request."
+        detail = "More information has been logged on the backend."
+
+        body = {
+            "message": message,
+            "detail": detail,
+            "logged": True,
+        }
+
+        user_message = f"{message} {detail}"
+        console_message = detail
+        if reference_id:
+            body["reference_id"] = str(reference_id)
+            user_message = f"{user_message} Reference: {reference_id}."
+            console_message = f"{console_message} Reference: {reference_id}."
+
+        response.set_status(500)
+        response.set_body(body)
+        response.console(console_message, title=title)
+        response.alert(user_message, title=title)
+        return True
+
     def _is_transient_db_disconnect(self, exc: Exception = None, *args, **kwargs) -> bool:
         """Return True if an exception looks like a transient DB disconnect.
 

velocity_python-0.0.213/src/velocity/aws/tests/test_base_handler_error_response.py

@@ -0,0 +1,62 @@
+import json
+import unittest
+from types import SimpleNamespace
+
+from velocity.aws.handlers.base_handler import BaseHandler
+from velocity.aws.handlers.response import Response
+
+
+class DummyContext:
+    def __init__(self, response):
+        self._response = response
+
+    def response(self):
+        return self._response
+
+    def action(self):
+        return "button-click"
+
+
+class DummyHandler(BaseHandler):
+    def __init__(self, aws_context=None):
+        super().__init__({}, aws_context or SimpleNamespace(aws_request_id="req-123"))
+        self.on_error_calls = []
+
+    def onError(self, tx, context, exc, tb):
+        self.on_error_calls.append({"exc": exc, "tb": tb})
+
+
+class TestBaseHandlerErrorResponse(unittest.TestCase):
+    def test_unhandled_http_error_sets_generic_response(self):
+        handler = DummyHandler()
+        response = Response()
+        context = DummyContext(response)
+
+        handler.handle_error(tx=None, local_context=context, exception=RuntimeError("secret details"))
+
+        self.assertEqual(response.status(), 500)
+        self.assertEqual(response.body["message"], "Something went wrong while processing your request.")
+        self.assertEqual(response.body["detail"], "More information has been logged on the backend.")
+        self.assertTrue(response.body["logged"])
+        self.assertEqual(response.body["reference_id"], "req-123")
+
+        rendered = response.render()
+        body = json.loads(rendered["body"])
+        self.assertEqual(rendered["statusCode"], 500)
+        self.assertEqual(len(body["actions"]), 2)
+        self.assertEqual(body["actions"][0]["action"], "console")
+        self.assertEqual(body["actions"][1]["action"], "alert")
+        self.assertIn("Reference: req-123.", body["actions"][1]["payload"]["message"])
+        self.assertNotIn("secret details", body["actions"][1]["payload"]["message"])
+        self.assertEqual(len(handler.on_error_calls), 1)
+
+    def test_unhandled_non_http_error_without_onerror_reraises(self):
+        handler = BaseHandler({}, SimpleNamespace(aws_request_id="req-456"))
+        context = DummyContext(None)
+
+        with self.assertRaises(RuntimeError):
+            handler.handle_error(tx=None, local_context=context, exception=RuntimeError("boom"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{velocity_python-0.0.211 → velocity_python-0.0.213}/src/velocity/misc/export.py

@@ -1,24 +1,120 @@
-from typing import List, Dict
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
 from io import BytesIO
+from typing import Dict, List
 import base64
+import re
+
 import openpyxl
-from openpyxl.styles import NamedStyle, Font, Border, Side, Alignment
+from openpyxl.styles import Alignment, Border, Font, NamedStyle, Side
 from openpyxl.utils import get_column_letter
 
 
+NUMBER_FORMAT_RE = re.compile(r"[#0?][#0?,]*(?:\.[#0?]+)?")
+
+
 def extract(d: dict, keys: List[str]) -> List:
     """Extract values from a dictionary based on a list of keys."""
     return [d.get(key) for key in keys]
 
 
-def autosize_columns(ws, fixed: Dict[str, float] = {}):
+def _stringify_cell_value(value) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "TRUE" if value else "FALSE"
+    return str(value)
+
+
+def _select_number_format_section(format_code: str, value) -> str:
+    sections = format_code.split(";")
+    if not sections:
+        return format_code
+    if value < 0 and len(sections) > 1:
+        return sections[1]
+    if value == 0 and len(sections) > 2:
+        return sections[2]
+    return sections[0]
+
+
+def _clean_number_format(format_code: str) -> str:
+    cleaned = []
+    in_quotes = False
+    idx = 0
+    while idx < len(format_code):
+        char = format_code[idx]
+        if char == '"':
+            in_quotes = not in_quotes
+        elif in_quotes:
+            cleaned.append(char)
+        elif char == "\\":
+            idx += 1
+            if idx < len(format_code):
+                cleaned.append(format_code[idx])
+        elif char in {"_", "*"}:
+            idx += 1
+        elif char == "[":
+            end = format_code.find("]", idx + 1)
+            if end == -1:
+                break
+            idx = end
+        else:
+            cleaned.append(char)
+        idx += 1
+    return "".join(cleaned)
+
+
+def _format_numeric_value(value, format_code: str) -> str:
+    section = _clean_number_format(_select_number_format_section(format_code, value))
+    if not section or section.lower() == "general":
+        return str(value)
+
+    match = NUMBER_FORMAT_RE.search(section)
+    if not match:
+        return str(value)
+
+    pattern = match.group(0)
+    prefix = section[: match.start()]
+    suffix = section[match.end() :]
+    percent_multiplier = section.count("%")
+    scaled_value = abs(value) * (100**percent_multiplier)
+    decimal_places = len(pattern.split(".", 1)[1]) if "." in pattern else 0
+    use_grouping = "," in pattern.split(".", 1)[0]
+
+    if use_grouping:
+        number = f"{scaled_value:,.{decimal_places}f}"
+    else:
+        number = f"{scaled_value:.{decimal_places}f}"
+
+    if value < 0 and len(format_code.split(";")) == 1 and "-" not in prefix and "(" not in prefix:
+        prefix = f"-{prefix}"
+
+    return f"{prefix}{number}{suffix}"
+
+
+def _display_value(cell) -> str:
+    value = cell.value
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "TRUE" if value else "FALSE"
+    if isinstance(value, (datetime, date, time, timedelta)):
+        return str(value)
+    if isinstance(value, (int, float, Decimal)):
+        return _format_numeric_value(value, cell.number_format)
+    return str(value)
+
+
+def autosize_columns(ws, fixed: Dict[str, float] | None = None):
     """Autosize columns in the worksheet based on content length."""
+    fixed = fixed or {}
     for col in ws.columns:
         max_length = 0
         for cell in col:
             try:
-                if cell.value and len(str(cell.value)) > max_length:
-                    max_length = len(str(cell.value))
+                display_value = _display_value(cell)
+                if len(display_value) > max_length:
+                    max_length = len(display_value)
             except Exception:
                 continue
         adjusted_width = (max_length + 2) * 1.2
@@ -30,15 +126,20 @@ def create_spreadsheet(
     headers: List[str],
     rows: List[List],
     fileorbuffer,
-    styles: Dict[str, str] = {},
-    merge: List[str] = [],
-    formats: Dict[str, str] = {},
-    named_styles: List[NamedStyle] = [],
+    styles: Dict[str, str] | None = None,
+    merge: List[str] | None = None,
+    formats: Dict[str, str] | None = None,
+    named_styles: List[NamedStyle] | None = None,
     freeze_panes: str = "A2",
     dimensions: dict = None,
     auto_size: bool = True,
 ):
     """Create an Excel spreadsheet with specified headers, rows, and styles."""
+    styles = styles or {}
+    merge = merge or []
+    formats = formats or {}
+    named_styles = named_styles or []
+
     wb = openpyxl.Workbook()
     ws = wb.active
 
@@ -102,6 +203,9 @@ def create_spreadsheet(
     # Set freeze panes
     ws.freeze_panes = freeze_panes
 
+    for cell, format_code in formats.items():
+        ws[cell].number_format = format_code
+
     # Auto-size columns if enabled
     if auto_size:
         autosize_columns(ws, fixed={})
@@ -119,8 +223,6 @@ def create_spreadsheet(
             ws[cell].style = local_styles[style_name]
     for cell_range in merge:
         ws.merge_cells(cell_range)
-    for cell, format_code in formats.items():
-        ws[cell].number_format = format_code
 
     # Save workbook to the provided file or buffer
     wb.save(fileorbuffer)
@@ -129,10 +231,10 @@ def create_spreadsheet(
 def get_downloadable_spreadsheet(
     headers: List[str],
     rows: List[List],
-    styles: Dict[str, str] = {},
-    merge: List[str] = [],
-    formats: Dict[str, str] = {},
-    named_styles: List[NamedStyle] = [],
+    styles: Dict[str, str] | None = None,
+    merge: List[str] | None = None,
+    formats: Dict[str, str] | None = None,
+    named_styles: List[NamedStyle] | None = None,
     freeze_panes: str = "A2",
     dimensions: dict = None,
     auto_size: bool = True,

{velocity_python-0.0.211 → velocity_python-0.0.213}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.211
+Version: 0.0.213
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.211 → velocity_python-0.0.213}/src/velocity_python.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/velocity/aws/handlers/mixins/__init__.py
 src/velocity/aws/handlers/mixins/data_service.py
 src/velocity/aws/handlers/mixins/web_handler.py
 src/velocity/aws/tests/__init__.py
+src/velocity/aws/tests/test_base_handler_error_response.py
 src/velocity/aws/tests/test_lambda_handler_json_serialization.py
 src/velocity/aws/tests/test_response.py
 src/velocity/db/__init__.py