velocity-python 0.0.198__tar.gz → 0.0.200__tar.gz

{velocity_python-0.0.198 → velocity_python-0.0.200}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.198
+Version: 0.0.200
 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.198 → velocity_python-0.0.200}/pyproject.toml

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

{velocity_python-0.0.198 → velocity_python-0.0.200}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.198"
+__version__ = version = "0.0.200"
 
 from . import aws
 from . import db

{velocity_python-0.0.198 → velocity_python-0.0.200}/src/velocity/aws/handlers/lambda_handler.py

@@ -18,6 +18,12 @@ logger = logging.getLogger(__name__)
 
 class LambdaHandler(BaseHandler):
     user_table: Optional[str] = None
+    # Auth behavior for HTTP-invoked lambdas.
+    # - required: must have Cognito identity and a DB user
+    # - optional: Cognito identity may be absent; DB user lookup is skipped unless present
+    # - none: no Cognito lookup; no DB user lookup
+    auth_mode: str = "required"
+    require_db_user: bool = True
     def __init__(
         self, 
         aws_event, 
@@ -42,18 +48,44 @@ class LambdaHandler(BaseHandler):
         logger.debug("starting LamdaHandler.beforeAction")
 
         
-        context.perf.start("get_cognito_user")
-        self.cognito_user = context.get_cognito_user(self.aws_event)
-        context.perf.log("get_cognito_user")
         self.current_user = {}
 
-        logger.debug("DEBUG: !!! cognito_user %s", self.cognito_user)
+        auth_mode = getattr(self, "auth_mode", "required") or "required"
+        require_db_user = bool(getattr(self, "require_db_user", True))
+
         session = context.session() or {}
+
+        public_actions = getattr(self, "public_actions", None)
         try:
-            email_address = self.cognito_user["attributes"]["email"]
-            session["email_address"] = email_address
+            current_action = context.action()
         except Exception:
-            logger.warning("Unable to read email from Cognito user", exc_info=True)
+            current_action = None
+
+        if (
+            current_action
+            and isinstance(public_actions, (list, tuple, set))
+            and current_action in public_actions
+        ):
+            auth_mode = "none"
+            require_db_user = False
+
+        if auth_mode == "none":
+            self.cognito_user = None
+        else:
+            context.perf.start("get_cognito_user")
+            if auth_mode == "optional":
+                self.cognito_user = context.get_cognito_user_optional(self.aws_event)
+            else:
+                self.cognito_user = context.get_cognito_user(self.aws_event)
+            context.perf.log("get_cognito_user")
+
+        logger.debug("DEBUG: !!! cognito_user %s", self.cognito_user)
+        if isinstance(self.cognito_user, dict):
+            try:
+                email_address = self.cognito_user["attributes"]["email"]
+                session["email_address"] = email_address
+            except Exception:
+                logger.warning("Unable to read email from Cognito user", exc_info=True)
 
         logger.info(
             "Starting action",
@@ -65,27 +97,32 @@ class LambdaHandler(BaseHandler):
             },
         )
 
-        if not self.user_table:
-            logger.warning(
-                "user_table not configured; skipping DB lookup for %s",
-                session.get("email_address"),
-            )
-            raise Exception(
-                "User table not configured; cannot validate user [Config]"
-            )
-        context.perf.start("user lookup")
-        row = tx.table(self.user_table).find(
-            {"email_address": session.get("email_address")}
-        )
-        context.perf.log("user lookup")
-        if not row:
-            raise Exception(
-                "A valid user with permission is required to access this function [DB]"
+        if require_db_user:
+            if not session.get("email_address"):
+                raise Exception("A valid user is required to access this function [Auth]")
+
+            if not self.user_table:
+                logger.warning(
+                    "user_table not configured; cannot validate user %s",
+                    session.get("email_address"),
+                )
+                raise Exception("User table not configured; cannot validate user [Config]")
+
+            context.perf.start("user lookup")
+            row = tx.table(self.user_table).find(
+                {"email_address": session.get("email_address")}
             )
-        self.current_user = row.to_dict()
+            context.perf.log("user lookup")
+            if not row:
+                raise Exception(
+                    "A valid user with permission is required to access this function [DB]"
+                )
+            self.current_user = row.to_dict()
          
-        temp = copy.deepcopy(context.postdata())
-        temp["payload"].pop("cognito_user", None)
+        temp = copy.deepcopy(context.postdata() or {})
+        payload = temp.get("payload")
+        if isinstance(payload, dict):
+            payload.pop("cognito_user", None)
         logger.debug(
             "Events.OnAction %s",
             temp.get("action"),
@@ -123,9 +160,11 @@ class LambdaHandler(BaseHandler):
 
         logger.debug("starting BackOfficeEvents.onError")
 
-        temp = copy.deepcopy(context.postdata())
+        temp = copy.deepcopy(context.postdata() or {})
         logger.debug("starting BackOfficeEvents.log")
-        temp["payload"].pop("cognito_user", None)
+        payload = temp.get("payload")
+        if isinstance(payload, dict):
+            payload.pop("cognito_user", None)
         logger.error(
             "Events.OnError %s",
             temp.get("action"),
@@ -189,10 +228,16 @@ class LambdaHandler(BaseHandler):
             sanitized_payload["sys_modified_by"] = session.get("email_address") or "system"
 
         if not email:
-            raise Exception(f"Tracking email could not be resolved for tracking.")
+            # Tracking should be best-effort and never break user flows.
+            logger.warning("Tracking email could not be resolved; skipping tracking write")
+            return
 
         table_name = context_obj.get_tracking_table(email)
 
+        if not table_name:
+            logger.warning("Tracking table could not be resolved; skipping tracking write")
+            return
+
         try:
             tx.table(table_name).insert(sanitized_payload)
         except Exception as exc:  # pragma: no cover - best effort logging
@@ -200,30 +245,24 @@ class LambdaHandler(BaseHandler):
 
     def validate(self, user_required=True):
         session = self.context.session() if self.context else {}
-        if user_required:
-            try:
-                attrs = self.cognito_user["attributes"]
-                assert attrs
-                assert attrs["email"]
-                assert attrs["sub"]
-                assert session["sub"]
-                assert session["sub"] == attrs["sub"]
-            except:
-                raise Exception("User Authentication Error [Cognito]")
-        else:
-            try:
-                if not session["sub"]:
-                    # User is not signed in. If user_required
-                    # is false, then simply return
-                    return
-                attrs = self.cognito_user["attributes"]
-                assert attrs
-                assert attrs["email"]
-                assert attrs["sub"]
-                assert session["sub"]
-                assert session["sub"] == attrs["sub"]
-            except:
-                raise Exception("User Authentication Error [Cognito]")
+        session_sub = session.get("sub")
+        cognito_user = getattr(self, "cognito_user", None)
+
+        if not user_required:
+            # Optional-auth flows: if there's no user in session, treat as anonymous.
+            if not session_sub:
+                return
+
+        try:
+            if not isinstance(cognito_user, dict):
+                raise Exception("Missing Cognito user")
+            attrs = cognito_user.get("attributes") or {}
+            email = attrs.get("email")
+            sub = attrs.get("sub")
+            if not email or not sub or not session_sub or session_sub != sub:
+                raise Exception("User mismatch")
+        except Exception:
+            raise Exception("User Authentication Error [Cognito]")
 
     def _summarize_postdata(self, postdata):
         """Extract key fields from postdata for logging without storing entire payload"""

{velocity_python-0.0.198 → velocity_python-0.0.200}/src/velocity/aws/handlers/mixins/web_handler.py

@@ -484,7 +484,7 @@ class ButtonHandler:
     module_name = None  # Override in subclass (e.g., 'buttons')
     
     @classmethod
-    def _get_button_module(cls, tx, handler):
+    def _get_button_module(cls, *args, **kwargs):
         """
         Load button-specific handler module if it exists.
         
@@ -495,6 +495,19 @@ class ButtonHandler:
             The loaded module or None if not found
             
         """
+        # NOTE: This helper is called from Lambda handlers that are often wrapped by
+        # velocity's transaction decorators. Those wrappers can inject extra positional
+        # arguments (including duplicate tx objects). To stay robust across versions,
+        # we accept *args and locate the handler name from strings.
+
+        handler = kwargs.get("handler")
+        if not handler:
+            string_args = [value for value in args if isinstance(value, str)]
+            handler = string_args[-1] if string_args else None
+
+        if not handler:
+            raise AlertError("Button handler name missing in request payload")
+
         if not cls.module_name:
             raise AlertError("ButtonHandler.module_name not set in subclass. This is a configuration issue that needs to be handled by the developer.")
         try:
@@ -503,7 +516,7 @@ class ButtonHandler:
             raise AlertError(f"Unable to import ButtonHandler module `{handler}`. Please ensure the code has been deployed.")
     
     @classmethod
-    def _get_button_function(cls, tx, handler, action):
+    def _get_button_function(cls, *args, **kwargs):
         """
         Get a specific function from a button handler module.
         
@@ -514,7 +527,21 @@ class ButtonHandler:
         Returns:
             The function object or None if not found
         """
-        module = cls._get_button_module(tx, handler)
+        handler = kwargs.get("handler")
+        action = kwargs.get("action")
+
+        if not handler or not action:
+            string_args = [value for value in args if isinstance(value, str)]
+            if len(string_args) >= 2:
+                handler = handler or string_args[-2]
+                action = action or string_args[-1]
+
+        if not handler:
+            raise AlertError("Button handler name missing in request payload")
+        if not action:
+            raise AlertError("Button action missing in request payload")
+
+        module = cls._get_button_module(handler=handler)
         
         # Convert action name: "refresh-data" -> "RefreshData"
         func_name = action.replace("-", " ").title().replace(" ", "")
@@ -558,7 +585,7 @@ class ButtonHandler:
         action = dataset["action"]
         
         # Resolve the function using the helper
-        func = self._get_button_function(tx, handler, action)
+        func = self.__class__._get_button_function(tx, handler, action)
        
         # Execute the button handler
         # Don't return its result to avoid triggering base handler warnings

{velocity_python-0.0.198 → velocity_python-0.0.200}/src/velocity/misc/conv/iconv.py

@@ -229,6 +229,31 @@ def money(data: str) -> Optional[Decimal]:
         return None
 
 
+def money_to_cents(value) -> int:
+    """Convert a dollars-like value to integer cents.
+
+    This is intentionally permissive and mirrors common app-layer behavior:
+    - None/"" => 0
+    - int/float/Decimal/str => dollars * 100, truncated toward 0
+
+    Notes:
+    - If you already have cents, do not pass them here.
+    """
+    if value is None:
+        return 0
+    if isinstance(value, int):
+        # Ambiguous (could be dollars or cents). Many apps pass dollars.
+        # Treat as dollars to preserve historical behavior.
+        return int(Decimal(str(value)) * 100)
+    if isinstance(value, (float, Decimal)):
+        return int(Decimal(str(value)) * 100)
+
+    raw = str(value).strip()
+    if raw == "":
+        return 0
+    return int(Decimal(raw) * 100)
+
+
 def round_to(
     precision: int, data: Optional[Union[str, float, Decimal]] = None
 ) -> Union[Decimal, Callable[[Union[str, float, Decimal]], Optional[Decimal]]]:

{velocity_python-0.0.198 → velocity_python-0.0.200}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.198
+Version: 0.0.200
 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.198 → velocity_python-0.0.200}/src/velocity_python.egg-info/SOURCES.txt

@@ -136,7 +136,9 @@ src/velocity_python.egg-info/dependency_links.txt
 src/velocity_python.egg-info/requires.txt
 src/velocity_python.egg-info/top_level.txt
 tests/test_decorators.py
+tests/test_iconv_money_to_cents.py
 tests/test_lambda_handler.py
+tests/test_lambda_handler_auth.py
 tests/test_mixins_import.py
 tests/test_sys_modified_count_postgres_demo.py
 tests/test_table_alter.py

velocity_python-0.0.200/tests/test_iconv_money_to_cents.py

@@ -0,0 +1,20 @@
+import decimal
+
+from velocity.misc.conv import iconv
+
+
+def test_money_to_cents_none_and_empty():
+    assert iconv.money_to_cents(None) == 0
+    assert iconv.money_to_cents("") == 0
+    assert iconv.money_to_cents("   ") == 0
+
+
+def test_money_to_cents_numeric_types():
+    assert iconv.money_to_cents(10) == 1000
+    assert iconv.money_to_cents(10.5) == 1050
+    assert iconv.money_to_cents(decimal.Decimal("10.50")) == 1050
+
+
+def test_money_to_cents_string_values():
+    assert iconv.money_to_cents("10") == 1000
+    assert iconv.money_to_cents("10.50") == 1050

velocity_python-0.0.200/tests/test_lambda_handler_auth.py

@@ -0,0 +1,77 @@
+import unittest
+
+from velocity.aws.handlers.lambda_handler import LambdaHandler
+
+
+class _Perf:
+    def start(self, *args, **kwargs):
+        return None
+
+    def log(self, *args, **kwargs):
+        return None
+
+
+class _Context:
+    def __init__(self, action=None, postdata=None, session=None):
+        self._action = action
+        self._postdata = postdata
+        self._session = session if isinstance(session, dict) else {}
+        self.perf = _Perf()
+
+    def action(self):
+        return self._action
+
+    def args(self):
+        return {}
+
+    def postdata(self):
+        return self._postdata
+
+    def session(self):
+        return self._session
+
+    def get_cognito_user(self, aws_event):  # pragma: no cover
+        raise AssertionError("get_cognito_user should not be called")
+
+    def get_cognito_user_optional(self, aws_event):  # pragma: no cover
+        raise AssertionError("get_cognito_user_optional should not be called")
+
+
+class _Handler(LambdaHandler):
+    def _enhanced_before_action(self, tx, context):
+        return False
+
+    def _enhanced_error_handler(self, tx, context, exc, tb):
+        return False
+
+
+class TestLambdaHandlerAuthModes(unittest.TestCase):
+    def test_auth_mode_none_skips_cognito(self):
+        h = _Handler(aws_event={}, aws_context=type("C", (), {"aws_request_id": "rid"})())
+        h.auth_mode = "none"
+        h.require_db_user = False
+        h.beforeAction(tx=object(), context=_Context(action="anything", postdata={}))
+
+    def test_public_actions_bypass_auth_and_db_user(self):
+        h = _Handler(aws_event={}, aws_context=type("C", (), {"aws_request_id": "rid"})())
+        h.auth_mode = "required"
+        h.require_db_user = True
+        h.user_table = "users"
+        h.public_actions = ["public-action"]
+
+        # Should not call cognito, should not require session email
+        h.beforeAction(tx=object(), context=_Context(action="public-action", postdata={}))
+
+    def test_onerror_does_not_require_payload(self):
+        h = _Handler(aws_event={}, aws_context=type("C", (), {"aws_request_id": "rid"})())
+        h.onError(tx=object(), context=_Context(action="anything", postdata={}), exc="E", tb="TB")
+        h.onError(
+            tx=object(),
+            context=_Context(action="anything", postdata={"payload": "not-a-dict"}),
+            exc="E",
+            tb="TB",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()