velocity-python 0.0.105__py3-none-any.whl → 0.0.155__py3-none-any.whl

velocity/__init__.py

@@ -1,6 +1,8 @@
-__version__ = version = "0.0.98"
+__version__ = version = "0.0.155"
 
 from . import aws
 from . import db
 from . import misc
 from . import app
+
+__all__ = ["aws", "db", "misc", "app"]

velocity/app/orders.py

@@ -1,8 +1,9 @@
 import datetime
 import support.app
 import pprint
+import velocity.db
 
-engine = support.app.postgres()
+engine = velocity.db.postgres.initialize()
 REQUIRED = object()
 
 
@@ -114,9 +115,7 @@ class Order:
             for key, default in defaults.items():
                 if key not in target:
                     target[key] = default() if callable(default) else default
-                elif key == "updated_at":
-                    # Always update updated_at if present
-                    target[key] = default() if callable(default) else default
+
 
     def _validate(self):
         self._apply_defaults()

velocity/app/tests/__init__.py

@@ -0,0 +1 @@
+# App module tests

velocity/app/tests/test_email_processing.py

@@ -0,0 +1,112 @@
+import unittest
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.mime.application import MIMEApplication
+from velocity.misc.mail import (
+    Attachment,
+    get_full_emails,
+    get_address_only,
+    parse_attachment,
+    parse,
+)
+import hashlib
+
+
+class TestEmailProcessing(unittest.TestCase):
+
+    def test_get_full_emails(self):
+        """Test that email addresses with names are formatted correctly."""
+        mock_address = [
+            type(
+                "Address",
+                (),
+                {"mailbox": b"john", "host": b"example.com", "name": b"John Doe"},
+            ),
+            type(
+                "Address",
+                (),
+                {"mailbox": b"jane", "host": b"example.com", "name": None},
+            ),
+        ]
+        result = get_full_emails(mock_address)
+        self.assertEqual(result, ["John Doe <john@example.com>", "jane@example.com"])
+
+    def test_get_address_only(self):
+        """Test that only email addresses without names are returned."""
+        mock_address = [
+            type("Address", (), {"mailbox": b"john", "host": b"example.com"}),
+            type("Address", (), {"mailbox": b"jane", "host": b"example.com"}),
+        ]
+        result = get_address_only(mock_address)
+        self.assertEqual(result, ["john@example.com", "jane@example.com"])
+
+    def test_attachment_initialization(self):
+        """Test the initialization of the Attachment class."""
+        data = b"file data"
+        attachment = Attachment(name="file.txt", data=data)
+        self.assertEqual(attachment.name, "file.txt")
+        self.assertEqual(attachment.data, data)
+        self.assertEqual(attachment.size, len(data))
+        self.assertEqual(attachment.ctype, "text/plain")
+        self.assertEqual(attachment.hash, hashlib.sha1(data).hexdigest())
+
+    def test_parse_attachment(self):
+        """Test parsing a valid attachment from a message part."""
+        part = MIMEApplication(b"Test file data", Name="test.txt")
+        part["Content-Disposition"] = 'attachment; filename="test.txt"'
+        attachment = parse_attachment(part)
+        self.assertIsInstance(attachment, Attachment)
+        self.assertEqual(attachment.name, "test.txt")
+        self.assertEqual(attachment.ctype, "text/plain")
+        self.assertEqual(attachment.data, b"Test file data")
+
+    def test_parse_attachment_none(self):
+        """Test that parse_attachment returns None if there's no attachment."""
+        part = MIMEText("This is a plain text email part")
+        self.assertIsNone(parse_attachment(part))
+
+    def test_parse_plain_text_email(self):
+        """Test parsing a plain text email."""
+        msg = MIMEText("This is a plain text email")
+        msg["Content-Type"] = "text/plain"
+        result = parse(msg.as_string())
+        self.assertEqual(result["body"], "This is a plain text email")
+        self.assertIsNone(result["html"])
+        self.assertEqual(result["attachments"], [])
+
+    def test_parse_html_email(self):
+        """Test parsing an HTML email."""
+        msg = MIMEText("<p>This is an HTML email</p>", "html")
+        msg["Content-Type"] = "text/html"
+        result = parse(msg.as_string())
+        self.assertEqual(result["html"], "<p>This is an HTML email</p>")
+        self.assertIsNone(result["body"])
+        self.assertEqual(result["attachments"], [])
+
+    def test_parse_multipart_email_with_attachments(self):
+        """Test parsing a multipart email with attachments."""
+        msg = MIMEMultipart()
+        msg.attach(MIMEText("This is a plain text part", "plain"))
+        msg.attach(MIMEText("<p>This is an HTML part</p>", "html"))
+
+        attachment_part = MIMEApplication(b"Attachment data", Name="attachment.txt")
+        attachment_part["Content-Disposition"] = 'attachment; filename="attachment.txt"'
+        msg.attach(attachment_part)
+
+        result = parse(msg.as_string())
+        self.assertEqual(result["body"], "This is a plain text part")
+        self.assertEqual(result["html"], "<p>This is an HTML part</p>")
+        self.assertEqual(len(result["attachments"]), 1)
+        self.assertEqual(result["attachments"][0].name, "attachment.txt")
+        self.assertEqual(result["attachments"][0].data, b"Attachment data")
+
+    def test_parse_empty_email(self):
+        """Test parsing an empty email string."""
+        result = parse("")
+        self.assertIsNone(result["body"])
+        self.assertIsNone(result["html"])
+        self.assertEqual(result["attachments"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/app/tests/test_payment_profile_sorting.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Test for payment profile sorting with None expiration dates.
+
+This addresses the production error:
+TypeError: '<' not supported between instances of 'NoneType' and 'NoneType'
+
+The error occurs when sorting payment profiles by expiration_date when some values are None.
+"""
+
+import unittest
+from datetime import datetime
+
+
+class TestPaymentProfileSorting(unittest.TestCase):
+    """Test sorting payment profiles with various expiration date scenarios."""
+
+    def setUp(self):
+        """Set up test data with various expiration date scenarios."""
+        self.payment_profiles = [
+            {
+                "sys_id": 1,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": "2024-12",
+                "status": "active",
+            },
+            {
+                "sys_id": 2,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": "2024-06",
+                "status": "active",
+            },
+            {
+                "sys_id": 3,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": None,
+                "status": "active",
+            },
+            {
+                "sys_id": 4,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": "2025-01",
+                "status": "active",
+            },
+            {
+                "sys_id": 5,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": None,
+                "status": "active",
+            },
+        ]
+
+    def test_original_error_reproduction(self):
+        """Reproduce the original error to confirm it happens."""
+        with self.assertRaises(TypeError) as context:
+            # This should fail with the original error
+            sorted(self.payment_profiles, key=lambda x: x["expiration_date"])
+
+        self.assertIn(
+            "'<' not supported between instances of 'NoneType'", str(context.exception)
+        )
+
+    def test_safe_sorting_with_none_last(self):
+        """Test sorting with None values placed at the end."""
+
+        def safe_sort_key_none_last(row):
+            """Sort key that places None values at the end."""
+            exp_date = row["expiration_date"]
+            if exp_date is None:
+                return (1, "")  # (1, "") sorts after (0, any_date)
+            return (0, exp_date)
+
+        sorted_profiles = sorted(self.payment_profiles, key=safe_sort_key_none_last)
+
+        # Check that non-None dates come first and are in order
+        non_none_dates = [
+            p["expiration_date"]
+            for p in sorted_profiles
+            if p["expiration_date"] is not None
+        ]
+        self.assertEqual(non_none_dates, ["2024-06", "2024-12", "2025-01"])
+
+        # Check that None values come last
+        none_dates = [
+            p["expiration_date"]
+            for p in sorted_profiles
+            if p["expiration_date"] is None
+        ]
+        self.assertEqual(len(none_dates), 2)
+
+        # Verify the full sort order
+        expected_order = ["2024-06", "2024-12", "2025-01", None, None]
+        actual_order = [p["expiration_date"] for p in sorted_profiles]
+        self.assertEqual(actual_order, expected_order)
+
+    def test_safe_sorting_with_none_first(self):
+        """Test sorting with None values placed at the beginning."""
+
+        def safe_sort_key_none_first(row):
+            """Sort key that places None values at the beginning."""
+            exp_date = row["expiration_date"]
+            if exp_date is None:
+                return (0, "")  # (0, "") sorts before (1, any_date)
+            return (1, exp_date)
+
+        sorted_profiles = sorted(self.payment_profiles, key=safe_sort_key_none_first)
+
+        # Check that None values come first
+        none_count = sum(1 for p in sorted_profiles[:2] if p["expiration_date"] is None)
+        self.assertEqual(none_count, 2)
+
+        # Check that non-None dates come after and are in order
+        non_none_dates = [
+            p["expiration_date"]
+            for p in sorted_profiles
+            if p["expiration_date"] is not None
+        ]
+        self.assertEqual(non_none_dates, ["2024-06", "2024-12", "2025-01"])
+
+    def test_safe_sorting_with_default_date(self):
+        """Test sorting with None values replaced by a default date."""
+
+        def safe_sort_key_with_default(row):
+            """Sort key that replaces None with a default date."""
+            exp_date = row["expiration_date"]
+            if exp_date is None:
+                return "1900-01"  # Very old date so None values sort first
+            return exp_date
+
+        sorted_profiles = sorted(self.payment_profiles, key=safe_sort_key_with_default)
+
+        # Check that None values (now "1900-01") come first
+        none_count = sum(1 for p in sorted_profiles[:2] if p["expiration_date"] is None)
+        self.assertEqual(none_count, 2)
+
+        # Check the overall order
+        actual_order = [p["expiration_date"] for p in sorted_profiles]
+        expected_order = [None, None, "2024-06", "2024-12", "2025-01"]
+        self.assertEqual(actual_order, expected_order)
+
+    def test_grouped_sorting_scenario(self):
+        """Test the specific scenario from the billing handler."""
+        # Group profiles by email and card number (as in the original code)
+        groups = {}
+        for row in self.payment_profiles:
+            key = (row["email_address"], row["card_number"])
+            if key not in groups:
+                groups[key] = []
+            groups[key].append(row)
+
+        # Process each group with safe sorting
+        for group in groups.values():
+            # This should not raise an error
+            def safe_sort_key(row):
+                exp_date = row["expiration_date"]
+                return (exp_date is None, exp_date or "")
+
+            sorted_group = sorted(group, key=safe_sort_key)
+
+            # Verify we can enumerate through the sorted group
+            for idx, row in enumerate(sorted_group):
+                self.assertIsInstance(idx, int)
+                self.assertIn("sys_id", row)
+                self.assertIn("expiration_date", row)
+
+
+def safe_expiration_date_sort_key(row):
+    """
+    Safe sorting key for payment profiles by expiration date.
+
+    Handles None values by placing them at the end of the sort order.
+
+    Args:
+        row: Dictionary representing a payment profile with 'expiration_date' key
+
+    Returns:
+        Tuple that can be safely sorted, with None values last
+    """
+    exp_date = row["expiration_date"]
+    if exp_date is None:
+        return (1, "")  # (1, "") sorts after (0, any_date)
+    return (0, exp_date)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/app/tests/test_spreadsheet_functions.py

@@ -0,0 +1,124 @@
+import unittest
+import base64
+from io import BytesIO
+from openpyxl import load_workbook
+from velocity.misc.export import (
+    extract,
+    autosize_columns,
+    create_spreadsheet,
+    get_downloadable_spreadsheet,
+)
+
+
+class TestSpreadsheetFunctions(unittest.TestCase):
+
+    def test_extract(self):
+        """Test extracting values from a dictionary based on a list of keys."""
+        data = {"name": "Alice", "age": 30, "city": "Wonderland"}
+        keys = ["name", "city", "nonexistent_key"]
+        result = extract(data, keys)
+        self.assertEqual(result, ["Alice", "Wonderland", None])
+
+    def test_autosize_columns(self):
+        """Test that the columns are autosized based on the content."""
+        buffer = BytesIO()
+        headers = ["Column1", "Column2"]
+        rows = [["Short", "This is a longer text that should set the column width"]]
+
+        # Create a workbook and worksheet
+        create_spreadsheet(headers, rows, buffer)
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Run autosize_columns on the loaded worksheet
+        autosize_columns(worksheet)
+
+        # Check if the column widths were adjusted properly
+        col1_width = worksheet.column_dimensions["A"].width
+        col2_width = worksheet.column_dimensions["B"].width
+        self.assertGreater(col2_width, col1_width)
+
+    def test_create_spreadsheet_basic(self):
+        """Test creating a spreadsheet with headers and rows."""
+        buffer = BytesIO()
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"], ["Row2-Col1", "Row2-Col2"]]
+
+        create_spreadsheet(headers, rows, buffer)
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify headers and rows
+        self.assertEqual(worksheet["A1"].value, "Header1")
+        self.assertEqual(worksheet["B1"].value, "Header2")
+        self.assertEqual(worksheet["A2"].value, "Row1-Col1")
+        self.assertEqual(worksheet["B2"].value, "Row1-Col2")
+        self.assertEqual(worksheet["A3"].value, "Row2-Col1")
+        self.assertEqual(worksheet["B3"].value, "Row2-Col2")
+
+    def test_create_spreadsheet_with_styles_and_merge(self):
+        """Test creating a spreadsheet with custom styles and merged cells."""
+        buffer = BytesIO()
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"]]
+        styles = {"A1": "col_header", "B1": "col_header"}
+        merge = ["A1:B1"]
+
+        create_spreadsheet(headers, rows, buffer, styles=styles, merge=merge)
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify merged cells and styles
+        self.assertTrue(worksheet.merged_cells.ranges)
+        self.assertEqual(str(worksheet.merged_cells.ranges[0]), "A1:B1")
+        self.assertEqual(worksheet["A1"].style, "col_header")
+        self.assertEqual(worksheet["B1"].style, "col_header")
+
+    def test_create_spreadsheet_with_freeze_panes_and_dimensions(self):
+        """Test creating a spreadsheet with freeze panes and custom row/column dimensions."""
+        buffer = BytesIO()
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"]]
+        dimensions = {"rows": {1: 25}, "columns": {"A": 20, "B": 30}}
+
+        create_spreadsheet(
+            headers, rows, buffer, freeze_panes="A2", dimensions=dimensions
+        )
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify freeze panes and custom dimensions
+        self.assertEqual(worksheet.freeze_panes, "A2")
+        self.assertEqual(worksheet.row_dimensions[1].height, 25)
+        self.assertEqual(worksheet.column_dimensions["A"].width, 20)
+        self.assertEqual(worksheet.column_dimensions["B"].width, 30)
+
+    def test_get_downloadable_spreadsheet(self):
+        """Test generating a downloadable spreadsheet encoded in base64."""
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"], ["Row2-Col1", "Row2-Col2"]]
+
+        # Generate the base64-encoded spreadsheet
+        encoded_spreadsheet = get_downloadable_spreadsheet(headers, rows)
+        decoded_data = base64.b64decode(encoded_spreadsheet)
+
+        # Load the spreadsheet from the decoded data and verify its content
+        buffer = BytesIO(decoded_data)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify headers and rows
+        self.assertEqual(worksheet["A1"].value, "Header1")
+        self.assertEqual(worksheet["B1"].value, "Header2")
+        self.assertEqual(worksheet["A2"].value, "Row1-Col1")
+        self.assertEqual(worksheet["B2"].value, "Row1-Col2")
+        self.assertEqual(worksheet["A3"].value, "Row2-Col1")
+        self.assertEqual(worksheet["B3"].value, "Row2-Col2")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/aws/__init__.py

@@ -18,3 +18,6 @@ class AWS(object):
         response = requests.get("http://169.254.169.254/latest/meta-data/instance-id")
         instance_id = response.text
         return instance_id
+
+
+__all__ = ["AmplifyProject", "AWS"]

velocity/aws/amplify.py

@@ -1,4 +1,5 @@
 import boto3
+import time
 
 
 class AmplifyProject:
@@ -325,7 +326,12 @@ class AmplifyProject:
                 "ec2:AttachNetworkInterface",
                 "ec2:DescribeNetworkInterfaces",
                 "ec2:DeleteNetworkInterface",
-                "cognito-idp:*",
+                "ec2:DescribeSecurityGroups",
+                "ec2:AuthorizeSecurityGroupIngress",
+                "ec2:AuthorizeSecurityGroupEgress",
+                "ec2:RevokeSecurityGroupIngress",
+                "ec2:RevokeSecurityGroupEgress",
+                "cognito-idp:*"
             ],
         }
     ],
@@ -389,10 +395,9 @@ class AmplifyProject:
             except Exception:
                 pass
 
-    def check_policies(
-        self,
-    ):
+    def check_policies(self, function):
         # Attach a role policy
+        iam_client = boto3.client("iam")
         response = iam_client.list_attached_role_policies(
             RoleName=function["Role"].split("/")[1]
         )
@@ -426,7 +431,7 @@ class AmplifyProject:
         print(f"\n🔧 Applying {len(env_vars)} environment variables...")
         for function_name in self.list_lambda_functions_filtered(branch):
             print(f"➡️ Updating Lambda function: {function_name}")
-            self.update_lambda_env(function_name, env_vars)
+            self.update_lambda_function(function_name, env_vars)
 
         print(
             "✅ Environment variables successfully applied to matching Lambda functions.\n"
@@ -435,7 +440,6 @@ class AmplifyProject:
 
 def main():
     app_id = "d3c209q3ri53mk"
-    branch = "demo"
     app = AmplifyProject(app_id)
     print(app.list_backend_branches())
 

velocity/aws/handlers/__init__.py

@@ -1,3 +1,5 @@
 from velocity.aws.handlers.response import Response
 from velocity.aws.handlers.lambda_handler import LambdaHandler
 from velocity.aws.handlers.sqs_handler import SqsHandler
+
+__all__ = ["Response", "LambdaHandler", "SqsHandler"]