velocity-python 0.0.109__py3-none-any.whl → 0.0.161__py3-none-any.whl

velocity/db/utils.py

@@ -1,119 +1,190 @@
-"""
-Database utility functions for common operations.
+"""Utility helpers for velocity.db modules.
 
-This module provides utility functions to handle common database operations
-safely, including sorting with None values and other edge cases.
+This module provides helpers for redacting sensitive configuration values along
+with common collection utilities used across the velocity database codebase.
 """
 
-from typing import Any, Callable, List, Optional, Union
+import re
+from typing import Any, Callable, List
+
+_SENSITIVE_KEYWORDS = {
+    "password",
+    "passwd",
+    "pwd",
+    "secret",
+    "token",
+    "apikey",
+    "api_key",
+}
+
+_SENSITIVE_PATTERNS = [
+    re.compile(r"(password\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(passwd\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(pwd\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(secret\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(token\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(api[_-]?key\s*=\s*)([^\s;]+)", re.IGNORECASE),
+]
+
+_URL_CREDENTIAL_PATTERN = re.compile(r"(://[^:\s]+:)([^@/\s]+)")
+
+
+def mask_sensitive_in_string(value: str) -> str:
+    """Return ``value`` with credential-like substrings redacted."""
+
+    if not value:
+        return value
+
+    masked = value
+    for pattern in _SENSITIVE_PATTERNS:
+        masked = pattern.sub(lambda match: match.group(1) + "*****", masked)
+
+    return _URL_CREDENTIAL_PATTERN.sub(r"\1*****", masked)
+
+
+def mask_config_for_display(config: Any) -> Any:
+    """Return ``config`` with common secret fields masked for logging/str()."""
+
+    if isinstance(config, dict):
+        masked = {}
+        for key, value in config.items():
+            if isinstance(key, str) and _contains_sensitive_keyword(key):
+                masked[key] = "*****"
+            else:
+                masked[key] = mask_config_for_display(value)
+        return masked
+
+    if isinstance(config, tuple):
+        return tuple(mask_config_for_display(item) for item in config)
+
+    if isinstance(config, list):
+        return [mask_config_for_display(item) for item in config]
+
+    if isinstance(config, str):
+        return mask_sensitive_in_string(config)
+
+    return config
+
+
+def _contains_sensitive_keyword(key: str) -> bool:
+    lowered = key.lower()
+    return any(token in lowered for token in _SENSITIVE_KEYWORDS)
 
 
 def safe_sort_key_none_last(field_name: str) -> Callable[[dict], tuple]:
     """
     Create a sort key function that places None values at the end.
-    
+
     Args:
         field_name: Name of the field to sort by
-        
+
     Returns:
         A function suitable for use as a sort key that handles None values
-        
+
     Example:
         rows = [{"date": "2024-01"}, {"date": None}, {"date": "2023-12"}]
         sorted_rows = sorted(rows, key=safe_sort_key_none_last("date"))
         # Result: [{"date": "2023-12"}, {"date": "2024-01"}, {"date": None}]
     """
+
     def sort_key(row: dict) -> tuple:
         value = row.get(field_name)
         if value is None:
             return (1, "")  # None values sort last
         return (0, value)
-    
+
     return sort_key
 
 
 def safe_sort_key_none_first(field_name: str) -> Callable[[dict], tuple]:
     """
     Create a sort key function that places None values at the beginning.
-    
+
     Args:
         field_name: Name of the field to sort by
-        
+
     Returns:
         A function suitable for use as a sort key that handles None values
-        
+
     Example:
         rows = [{"date": "2024-01"}, {"date": None}, {"date": "2023-12"}]
         sorted_rows = sorted(rows, key=safe_sort_key_none_first("date"))
         # Result: [{"date": None}, {"date": "2023-12"}, {"date": "2024-01"}]
     """
+
     def sort_key(row: dict) -> tuple:
         value = row.get(field_name)
         if value is None:
             return (0, "")  # None values sort first
         return (1, value)
-    
+
     return sort_key
 
 
-def safe_sort_key_with_default(field_name: str, default_value: Any = "") -> Callable[[dict], Any]:
+def safe_sort_key_with_default(
+    field_name: str, default_value: Any = ""
+) -> Callable[[dict], Any]:
     """
     Create a sort key function that replaces None values with a default.
-    
+
     Args:
         field_name: Name of the field to sort by
         default_value: Value to use for None entries
-        
+
     Returns:
         A function suitable for use as a sort key that handles None values
-        
+
     Example:
         rows = [{"date": "2024-01"}, {"date": None}, {"date": "2023-12"}]
         sorted_rows = sorted(rows, key=safe_sort_key_with_default("date", "1900-01"))
         # Result: [{"date": None}, {"date": "2023-12"}, {"date": "2024-01"}]
     """
+
     def sort_key(row: dict) -> Any:
         value = row.get(field_name)
         return default_value if value is None else value
-    
+
     return sort_key
 
 
-def safe_sort_rows(rows: List[dict], field_name: str, 
-                   none_handling: str = "last", 
-                   default_value: Any = "",
-                   reverse: bool = False) -> List[dict]:
+def safe_sort_rows(
+    rows: List[dict],
+    field_name: str,
+    none_handling: str = "last",
+    default_value: Any = "",
+    reverse: bool = False,
+) -> List[dict]:
     """
     Safely sort a list of dictionaries by a field that may contain None values.
-    
+
     Args:
         rows: List of dictionaries to sort
         field_name: Name of the field to sort by
         none_handling: How to handle None values - "first", "last", or "default"
         default_value: Default value to use when none_handling is "default"
         reverse: Whether to reverse the sort order
-        
+
     Returns:
         New list of dictionaries sorted by the specified field
-        
+
     Raises:
         ValueError: If none_handling is not a valid option
-        
+
     Example:
         rows = [
             {"name": "Alice", "date": "2024-01"},
             {"name": "Bob", "date": None},
             {"name": "Charlie", "date": "2023-12"}
         ]
-        
+
         # None values last
         sorted_rows = safe_sort_rows(rows, "date")
-        
-        # None values first  
+
+        # None values first
         sorted_rows = safe_sort_rows(rows, "date", none_handling="first")
-        
+
         # Replace None with default
-        sorted_rows = safe_sort_rows(rows, "date", none_handling="default", 
+        sorted_rows = safe_sort_rows(rows, "date", none_handling="default",
                                    default_value="1900-01")
     """
     if none_handling == "last":
@@ -123,37 +194,39 @@ def safe_sort_rows(rows: List[dict], field_name: str,
     elif none_handling == "default":
         key_func = safe_sort_key_with_default(field_name, default_value)
     else:
-        raise ValueError(f"Invalid none_handling option: {none_handling}. "
-                        "Must be 'first', 'last', or 'default'")
-    
+        raise ValueError(
+            f"Invalid none_handling option: {none_handling}. "
+            "Must be 'first', 'last', or 'default'"
+        )
+
     return sorted(rows, key=key_func, reverse=reverse)
 
 
 def group_by_fields(rows: List[dict], *field_names: str) -> dict:
     """
     Group rows by one or more field values.
-    
+
     Args:
         rows: List of dictionaries to group
         *field_names: Names of fields to group by
-        
+
     Returns:
         Dictionary where keys are tuples of field values and values are lists of rows
-        
+
     Example:
         rows = [
             {"email": "alice@example.com", "type": "premium", "amount": 100},
             {"email": "alice@example.com", "type": "basic", "amount": 50},
             {"email": "bob@example.com", "type": "premium", "amount": 100},
         ]
-        
+
         # Group by email only
         groups = group_by_fields(rows, "email")
         # Result: {
         #     ("alice@example.com",): [row1, row2],
         #     ("bob@example.com",): [row3]
         # }
-        
+
         # Group by email and type
         groups = group_by_fields(rows, "email", "type")
         # Result: {
@@ -168,34 +241,37 @@ def group_by_fields(rows: List[dict], *field_names: str) -> dict:
         if key not in groups:
             groups[key] = []
         groups[key].append(row)
-    
+
     return groups
 
 
-def safe_sort_grouped_rows(grouped_rows: dict, field_name: str,
-                          none_handling: str = "last",
-                          default_value: Any = "",
-                          reverse: bool = False) -> dict:
+def safe_sort_grouped_rows(
+    grouped_rows: dict,
+    field_name: str,
+    none_handling: str = "last",
+    default_value: Any = "",
+    reverse: bool = False,
+) -> dict:
     """
     Safely sort rows within each group of a grouped result.
-    
+
     Args:
         grouped_rows: Dictionary of grouped rows (from group_by_fields)
         field_name: Name of the field to sort by within each group
         none_handling: How to handle None values - "first", "last", or "default"
         default_value: Default value to use when none_handling is "default"
         reverse: Whether to reverse the sort order
-        
+
     Returns:
         Dictionary with the same keys but sorted lists as values
-        
+
     Example:
         # After grouping payment profiles by email and card number
         groups = group_by_fields(payment_profiles, "email_address", "card_number")
-        
+
         # Sort each group by expiration date, with None values last
         sorted_groups = safe_sort_grouped_rows(groups, "expiration_date")
-        
+
         # Now process each sorted group
         for group_key, sorted_group in sorted_groups.items():
             for idx, row in enumerate(sorted_group):
@@ -204,6 +280,8 @@ def safe_sort_grouped_rows(grouped_rows: dict, field_name: str,
     """
     result = {}
     for key, rows in grouped_rows.items():
-        result[key] = safe_sort_rows(rows, field_name, none_handling, default_value, reverse)
-    
+        result[key] = safe_sort_rows(
+            rows, field_name, none_handling, default_value, reverse
+        )
+
     return result

velocity/misc/conv/__init__.py

@@ -1,2 +1,4 @@
 from . import iconv
 from . import oconv
+
+__all__ = ["iconv", "oconv"]

velocity/misc/conv/iconv.py

@@ -1,6 +1,7 @@
 import re
 import ast
 import codecs
+import decimal
 from decimal import Decimal, ROUND_HALF_UP
 from email.utils import parseaddr
 from datetime import datetime
@@ -224,7 +225,7 @@ def money(data: str) -> Optional[Decimal]:
         return None
     try:
         return Decimal(cleaned)
-    except:
+    except (ValueError, TypeError, decimal.InvalidOperation):
         return None
 
 
@@ -246,7 +247,7 @@ def round_to(
         cleaned = re.sub(r"[^0-9\.\-+]", "", val_str)
         try:
             as_dec = Decimal(cleaned)
-        except:
+        except (ValueError, TypeError, decimal.InvalidOperation):
             return None
         return as_dec.quantize(Decimal(10) ** -precision, rounding=ROUND_HALF_UP)
 
@@ -269,7 +270,7 @@ def decimal_val(data: str) -> Optional[Decimal]:
         return None
     try:
         return Decimal(cleaned)
-    except:
+    except (ValueError, TypeError, decimal.InvalidOperation):
         return None
 
 
@@ -305,7 +306,7 @@ def to_list(data: Union[str, list, None]) -> Optional[list]:
     if data_str.startswith("[") and data_str.endswith("]"):
         try:
             return ast.literal_eval(data_str)
-        except:
+        except (ValueError, SyntaxError):
             return [data_str]  # fallback: treat as a single string
     return [data_str]
 

velocity/misc/export.py

@@ -1,7 +1,4 @@
-import decimal
-import json
-from datetime import datetime, date, time, timedelta
-from typing import Union, List, Dict
+from typing import List, Dict
 from io import BytesIO
 import base64
 import openpyxl

velocity/misc/merge.py

@@ -1,6 +1,6 @@
 from copy import deepcopy
 from functools import reduce
-from typing import Dict, List, Any
+from typing import Dict, Any
 
 
 def deep_merge(*dicts: Dict[str, Any], update: bool = False) -> Dict[str, Any]:

velocity/misc/tests/__init__.py

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

velocity/misc/tests/test_db.py

@@ -0,0 +1,90 @@
+import unittest
+from unittest.mock import MagicMock, patch
+import numbers
+from functools import wraps
+from velocity.db import exceptions
+from ..db import NOTNULL, join, randomword, return_default, NotSupported
+
+
+class TestNotSupported(unittest.TestCase):
+    def test_not_supported(self):
+        with self.assertRaises(Exception) as context:
+            NotSupported()
+        self.assertEqual(
+            str(context.exception),
+            "Sorry, the driver for this database is not installed",
+        )
+
+
+class TestNOTNULL(unittest.TestCase):
+    def test_notnull(self):
+        self.assertTrue(NOTNULL(("key", "value")))
+        self.assertFalse(NOTNULL(("key", None)))
+        self.assertFalse(NOTNULL(("key",)))
+        self.assertFalse(NOTNULL(()))
+
+
+class TestJoin(unittest.TestCase):
+    def test_or(self):
+        self.assertEqual(join._or("a=1", "b=2"), "(a=1 or b=2)")
+
+    def test_and(self):
+        self.assertEqual(join._and("a=1", "b=2"), "(a=1 and b=2)")
+
+    def test_list(self):
+        result = join._list("a=1", key1=123, key2="value")
+        self.assertIn("a=1", result)
+        self.assertIn("key1=123", result)
+        self.assertIn("key2='value'", result)
+
+
+class TestRandomWord(unittest.TestCase):
+    def test_randomword_length_specified(self):
+        word = randomword(10)
+        self.assertEqual(len(word), 10)
+        self.assertTrue(word.islower())
+
+    def test_randomword_length_random(self):
+        word = randomword()
+        self.assertTrue(5 <= len(word) <= 15)
+        self.assertTrue(word.islower())
+
+
+class TestReturnDefault(unittest.TestCase):
+    def setUp(self):
+        class MockTransaction:
+            def create_savepoint(self, cursor):
+                return "savepoint"
+
+            def rollback_savepoint(self, sp, cursor):
+                pass
+
+            def release_savepoint(self, sp, cursor):
+                pass
+
+        class MockTable:
+            cursor = MagicMock()
+
+        class MockClass:
+            tx = MockTransaction()
+            table = MockTable()
+
+            @return_default(default="default_value")
+            def func(self, raise_exception=False):
+                if raise_exception:
+                    raise exceptions.DbApplicationError("Test error")
+                return "result"
+
+        self.mock_obj = MockClass()
+
+    def test_return_default_no_exception(self):
+        result = self.mock_obj.func(raise_exception=False)
+        self.assertEqual(result, "result")
+
+    def test_return_default_with_exception(self):
+        result = self.mock_obj.func(raise_exception=True)
+        self.assertEqual(result, "default_value")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/misc/tests/test_fix.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+# Test script to verify the duplicate_rows fix
+
+
+def test_grouping_fix():
+    """Test the fixed grouping logic"""
+
+    # Simulate duplicate rows that would come from duplicate_rows()
+    duplicate_rows = [
+        {
+            "sys_id": 1,
+            "email_address": "test1@example.com",
+            "card_number": "1234",
+            "expiration_date": "2024-01",
+            "status": None,
+        },
+        {
+            "sys_id": 2,
+            "email_address": "test1@example.com",
+            "card_number": "1234",
+            "expiration_date": "2024-02",
+            "status": None,
+        },
+        {
+            "sys_id": 3,
+            "email_address": "test2@example.com",
+            "card_number": "5678",
+            "expiration_date": "2024-03",
+            "status": None,
+        },
+        {
+            "sys_id": 4,
+            "email_address": "test2@example.com",
+            "card_number": "5678",
+            "expiration_date": "2024-01",
+            "status": None,
+        },
+    ]
+
+    # Group rows by email_address and card_number (the fixed logic)
+    groups = {}
+    for row in duplicate_rows:
+        key = (row["email_address"], row["card_number"])
+        if key not in groups:
+            groups[key] = []
+        groups[key].append(row)
+
+    print("Groups found:")
+    for key, group in groups.items():
+        print(f"  Key: {key}, Group size: {len(group)}")
+
+        # Test the sorting that was causing the original error
+        try:
+            sorted_group = sorted(group, key=lambda x: x["expiration_date"])
+            print(
+                f"    Sorted by expiration_date: {[row['expiration_date'] for row in sorted_group]}"
+            )
+
+            # Test the enumeration that happens in the original code
+            for idx, row in enumerate(sorted_group):
+                print(
+                    f"    {idx}: {row['sys_id']}, {row['email_address']}, {row['card_number']}, {row['expiration_date']}"
+                )
+
+        except TypeError as e:
+            print(f"    ERROR: {e}")
+            return False
+
+    return True
+
+
+if __name__ == "__main__":
+    success = test_grouping_fix()
+    if success:
+        print("\n✓ Fix appears to work correctly!")
+    else:
+        print("\n✗ Fix has issues")

velocity/misc/tests/test_format.py

@@ -0,0 +1,64 @@
+import unittest
+import decimal
+from datetime import datetime, date, time, timedelta
+from ..format import gallons, gallons2liters, currency, human_delta, to_json
+
+
+class TestYourModule(unittest.TestCase):
+
+    def test_gallons(self):
+        """Tests the gallons function with various inputs."""
+        self.assertEqual(gallons("10.5"), "10.50")
+        self.assertEqual(gallons(10.5), "10.50")
+        self.assertEqual(gallons(decimal.Decimal("10.5")), "10.50")
+        self.assertEqual(gallons(None), "")
+        self.assertEqual(gallons("invalid"), "")
+
+    def test_gallons2liters(self):
+        """Tests the gallons2liters function with various inputs."""
+        self.assertEqual(gallons2liters("10"), "37.85")  # 10 gallons to liters
+        self.assertEqual(gallons2liters(1), "3.79")  # 1 gallon to liters
+        self.assertEqual(gallons2liters(decimal.Decimal("1")), "3.79")
+        self.assertEqual(gallons2liters(None), "")
+        self.assertEqual(gallons2liters("invalid"), "")
+
+    def test_currency(self):
+        """Tests the currency function with various inputs."""
+        self.assertEqual(currency("1000.5"), "1000.50")
+        self.assertEqual(currency(1000.5), "1000.50")
+        self.assertEqual(currency(decimal.Decimal("1000.5")), "1000.50")
+        self.assertEqual(currency(None), "")
+        self.assertEqual(currency("invalid"), "")
+
+    def test_human_delta(self):
+        """Tests the human_delta function with various timedelta values."""
+        self.assertEqual(human_delta(timedelta(seconds=45)), "45 sec")
+        self.assertEqual(human_delta(timedelta(minutes=2, seconds=15)), "2 min 15 sec")
+        self.assertEqual(
+            human_delta(timedelta(hours=1, minutes=5)), "1 hr(s) 5 min 0 sec"
+        )
+        self.assertEqual(
+            human_delta(timedelta(days=2, hours=4, minutes=30)),
+            "2 day(s) 4 hr(s) 30 min 0 sec",
+        )
+
+    def test_to_json(self):
+        """Tests the to_json function with various custom objects."""
+        obj = {
+            "name": "Test",
+            "price": decimal.Decimal("19.99"),
+            "date": date(2023, 1, 1),
+            "datetime": datetime(2023, 1, 1, 12, 30, 45),
+            "time": time(12, 30, 45),
+            "duration": timedelta(days=1, hours=2, minutes=30),
+        }
+        result = to_json(obj)
+        self.assertIn('"price": 19.99', result)
+        self.assertIn('"date": "2023-01-01"', result)
+        self.assertIn('"datetime": "2023-01-01 12:30:45"', result)
+        self.assertIn('"time": "12:30:45"', result)
+        self.assertIn('"duration": "1 day(s) 2 hr(s) 30 min 0 sec"', result)
+
+
+if __name__ == "__main__":
+    unittest.main()