velocity-python 0.0.187__tar.gz → 0.0.189__tar.gz

{velocity_python-0.0.187/src/velocity_python.egg-info → velocity_python-0.0.189}/PKG-INFO

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

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

{velocity_python-0.0.187 → velocity_python-0.0.189}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.187"
+__version__ = version = "0.0.189"
 
 from . import aws
 from . import db

{velocity_python-0.0.187 → velocity_python-0.0.189}/src/velocity/aws/handlers/mixins/__init__.py

@@ -8,6 +8,6 @@ This package provides mixins for common Lambda handler patterns:
 """
 
 from .web_handler import WebHandler, ButtonHandler
-from .data_service import DataServiceMixin, RWXHookSystem, apply_sys_modified_by
+from .data_service import DataServiceMixin
 
-__all__ = ['WebHandler', 'ButtonHandler', 'DataServiceMixin', 'RWXHookSystem', 'apply_sys_modified_by']
+__all__ = ['WebHandler', 'ButtonHandler', 'DataServiceMixin',]

{velocity_python-0.0.187 → velocity_python-0.0.189}/src/velocity/aws/handlers/mixins/data_service.py

@@ -8,10 +8,13 @@ that uses velocity.db for database access.
 import base64
 import datetime
 import importlib
+import logging
 from io import BytesIO
 
 from velocity.misc import export
 
+logger = logging.getLogger(__name__)
+
 
 class DataServiceMixin:
     """
@@ -71,6 +74,7 @@ class DataServiceMixin:
             *args: Arguments to pass to the hook
             **kwargs: Keyword arguments to pass to the hook
         """
+        
         try:
             m = importlib.import_module(f".{table}", "rwx")
             if hasattr(m, hook_name):
@@ -275,10 +279,14 @@ class DataServiceMixin:
         if not any(value is not None for value in incoming.values()):
             raise ValueError("Parameter 'object' cannot contain only None values")
 
-        print(
-            f"WRITE_LOG: Writing to table {table_name} with sys_id {incoming.get('sys_id')}"
+        logger.debug(
+            "Writing to table",
+            extra={
+                "table_name": table_name,
+                "sys_id": incoming.get("sys_id"),
+                "object_keys": list(incoming.keys()),
+            },
         )
-        print(f"WRITE_LOG: Object keys: {list(incoming.keys())}")
 
         try:
             row = self.write_hook(
@@ -290,7 +298,10 @@ class DataServiceMixin:
             )
 
             if not row:
-                print(f"WARNING: self.write_hook returned empty row for table {table_name}")
+                logger.warning(
+                    "write_hook returned empty row",
+                    extra={"table_name": table_name},
+                )
                 row = {}
 
             context.response().set_body(
@@ -299,11 +310,20 @@ class DataServiceMixin:
                     "lastFetch": datetime.datetime.now(),
                 }
             )
-            print(f"WRITE_LOG: Successfully wrote to {table_name}")
+            logger.debug(
+                "Successfully wrote to table",
+                extra={"table_name": table_name},
+            )
 
         except Exception as e:
-            print(f"ERROR in OnActionWriteObject: {e}")
-            print(f"table_name={table_name}, incoming_keys={list(incoming.keys())}")
+            logger.error(
+                "Error in OnActionWriteObject",
+                extra={
+                    "exception": str(e),
+                    "table_name": table_name,
+                    "incoming_keys": list(incoming.keys()),
+                },
+            )
             raise
         context.response().load_object(row)
 
@@ -532,134 +552,3 @@ class DataServiceMixin:
                 )
             raise Exception(f"Failed to retrieve table schema: {str(e)}")
 
-
-class RWXHookSystem:
-    """
-    RWX (Read/Write/eXecute) hook system for table-specific business logic.
-    
-    This system allows you to create table-specific hook modules in an 'rwx' package
-    and have them automatically called during CRUD operations. This is useful for
-    adding custom business logic (validation, permissions, data enrichment) for
-    specific tables without modifying the generic DataServiceMixin.
-    
-    How it works:
-    1. Create a Python package called 'rwx' in your Lambda handler
-    2. For each table that needs custom logic, create a module (e.g., rwx/admin_users.py)
-    3. Define hook functions in the module (before_read, after_write, before_delete, etc.)
-    4. Subclass RWXHookSystem and set hook_module_name = 'rwx'
-    5. Use it from your handler class
-    
-    Example structure:
-        src/
-            index.py
-            rwx/
-                __init__.py
-                admin_users.py      # hooks for admin_users table
-                donors.py           # hooks for donors table
-    
-    Example hook in rwx/admin_users.py:
-        def before_write(tx, table, sys_id, incoming, context):
-            # Validate incoming data
-            if not incoming.get('email_address'):
-                raise ValueError("Email is required")
-            # Modify data
-            incoming['description'] = f"{incoming['full_name']} ({incoming['email_address']})"
-        
-        def after_read(tx, table, sys_id, row, context):
-            # Enrich response data
-            context.response().set_body({'extra_data': 'value'})
-    
-    Hook signatures:
-    - on_new(tx, table, row, context) - When creating new empty object
-    - before_read(tx, table, sys_id, context) - Before reading an object
-    - after_read(tx, table, sys_id, row, context) - After reading an object
-    - before_find(tx, table, query, context) - Before finding by query
-    - after_find(tx, table, query, row, context) - After finding by query
-    - before_new(tx, table, sys_id, incoming, context) - Before creating new object
-    - after_new(tx, table, sys_id, row, context) - After creating new object
-    - before_write(tx, table, sys_id, incoming, context) - Before write (insert/update)
-    - after_write(tx, table, sys_id, row, context) - After write (insert/update)
-    - before_delete(tx, table, sys_id, context) - Before deleting an object
-    - after_delete(tx, table, sys_id, context) - After deleting an object
-    - before_query(tx, table, payload, context) - Before querying objects
-    - after_query(tx, table, data, payload, context) - After querying objects
-    
-    Usage in a Lambda handler:
-        from velocity.aws.handlers.mixins import DataServiceMixin, RWXHookSystem
-        
-        class MyRWXSystem(RWXHookSystem):
-            hook_module_name = 'rwx'  # Name of your rwx package
-        
-        @engine.transaction
-        class HttpEventHandler(DataServiceMixin, LambdaHandler):
-            def __init__(self, aws_event, aws_context):
-                super().__init__(aws_event, aws_context)
-    """
-    
-    hook_module_name = None  # Override in subclass (e.g., 'rwx')
-    
-    @classmethod
-    def _get_table_module(cls, table):
-        """Load table-specific hook module if it exists"""
-        if not cls.hook_module_name:
-            return None
-        try:
-            return importlib.import_module(f".{table}", cls.hook_module_name)
-        except ImportError:
-            return None
-    
-    @classmethod
-    def _call_hook(cls, hook_name, table, *args, **kwargs):
-        """Call a hook on table-specific module if it exists"""
-        module = cls._get_table_module(table)
-        if module and hasattr(module, hook_name):
-            return getattr(module, hook_name)(*args, **kwargs)
-        return None
-
-
-def apply_sys_modified_by(incoming, context):
-    """
-    Strip sys_* fields and set sys_modified_by from context.
-    
-    Common pattern for applications that track who modified records.
-    Call this from your write_hook implementation.
-    
-    Args:
-        incoming: Dictionary of data being written
-        context: Request context with session/payload
-    """
-    payload = context.payload()
-    
-    # Strip system fields from incoming data
-    for key in list(incoming.keys()):
-        if "sys_" in key:
-            incoming.pop(key)
-    
-    # Extract email from session
-    session = context.session() if hasattr(context, "session") else None
-    email_address = None
-    
-    if isinstance(session, dict):
-        email_address = session.get("cognito_user_email")
-        if not email_address:
-            cognito_user = session.get("cognito_user")
-            if isinstance(cognito_user, dict):
-                email_address = cognito_user.get("email") or (
-                    cognito_user.get("attributes") or {}
-                ).get("email")
-        if not email_address:
-            email_address = session.get("email_address")
-    
-    if not email_address and isinstance(payload, dict):
-        payload_user = payload.get("cognito_user")
-        if isinstance(payload_user, dict):
-            email_address = payload_user.get("email") or (
-                payload_user.get("attributes") or {}
-            ).get("email")
-    
-    incoming["sys_modified_by"] = (
-        email_address.lower()
-        if isinstance(email_address, str)
-        else incoming.get("sys_modified_by", "unknown")
-    )
-    incoming["sys_dirty"] = True

{velocity_python-0.0.187 → velocity_python-0.0.189}/src/velocity/aws/handlers/mixins/web_handler.py

@@ -9,6 +9,7 @@ onError implementations in handlers.
 import copy
 import importlib
 import json
+import logging
 import os
 import pprint
 import time
@@ -18,6 +19,8 @@ from typing import Any, Dict, List
 
 from velocity.aws.handlers.exceptions import AlertError
 
+logger = logging.getLogger(__name__)
+
 class WebHandler(ABC):
     """
     Mixin providing unified activity tracking plus standardized error handling.
@@ -72,9 +75,12 @@ class WebHandler(ABC):
         try:
             self.activity_log_key = tx.table("aws_api_activity").new(self.activity_data).pk
         except Exception as exc:
-            context.log(
-                f"WebHandler.track_activity_start failed: {exc}; keys={list(self.activity_data.keys())}",
-                "WebHandler.track_activity_start",
+            logger.error(
+                "WebHandler.track_activity_start failed",
+                extra={
+                    "exception": str(exc),
+                    "activity_data_keys": list(self.activity_data.keys()),
+                },
             )
             raise
 
@@ -254,7 +260,7 @@ Request Details:
             html = html.replace("\n", "<br>").replace(" ", "&nbsp;")
             recipients = self._resolve_error_notification_recipients(tx, context)
             if not recipients:
-                print("No error notification recipients configured; skipping notification.")
+                logger.debug("No error notification recipients configured; skipping notification.")
                 return
 
             sender = self._resolve_error_notification_sender(tx, context)
@@ -271,7 +277,7 @@ Request Details:
                 email_settings_id=1001,
             )
         except Exception as email_error:  # pragma: no cover
-            print(f"Failed to send error notification email: {email_error}")
+            logger.error("Failed to send error notification email", extra={"error": str(email_error)})
 
     def _resolve_error_notification_recipients(self, tx, context) -> List[str]:
         recipients: List[str] = []
@@ -280,7 +286,7 @@ Request Details:
             try:
                 recipients = context_method(tx) or []
             except Exception as exc:
-                print(f"Failed to load recipients from context: {exc}")
+                logger.warning("Failed to load recipients from context", extra={"error": str(exc)})
         if recipients:
             return recipients
         return self._get_error_notification_recipients()
@@ -292,7 +298,7 @@ Request Details:
             try:
                 sender = context_method(tx)
             except Exception as exc:
-                print(f"Failed to load sender from context: {exc}")
+                logger.warning("Failed to load sender from context", extra={"error": str(exc)})
         if sender:
             return sender
         return self._get_error_notification_sender()

{velocity_python-0.0.187 → velocity_python-0.0.189/src/velocity_python.egg-info}/PKG-INFO

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