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

velocity/misc/tests/test_iconv.py

@@ -0,0 +1,203 @@
+import unittest
+from decimal import Decimal
+from datetime import date, datetime, time
+
+# Import all functions from iconv.py, renaming any that would clash with built-ins.
+from ..conv.iconv import (
+    none,
+    phone,
+    day_of_week,
+    date_conv,
+    time_conv,
+    timestamp,
+    email,
+    integer,
+    boolean,
+    rot13,
+    pointer,
+    money,
+    round_to,
+    decimal_val,
+    ein,
+    to_list,
+    title,
+    lower,
+    upper,
+    padding,
+    string,
+)
+
+
+class TestConverters(unittest.TestCase):
+
+    def test_none(self):
+        self.assertIsNone(none("None"))
+        self.assertIsNone(none("null"))
+        self.assertIsNone(none("@null"))
+        self.assertIsNone(none(""))
+        self.assertIsNone(none("   "))
+        self.assertEqual(none("Something"), "Something")
+
+    def test_phone(self):
+        self.assertIsNone(phone(None))
+        self.assertIsNone(phone("@null"))
+        self.assertIsNone(phone("999999"))
+        self.assertEqual(phone("1234567890"), "1234567890")
+        self.assertEqual(phone("(123) 456-7890"), "1234567890")
+        self.assertEqual(phone("1-234-567-8900"), "2345678900")  # leading '1' dropped
+        self.assertIsNone(phone("234567890"))  # only 9 digits
+        self.assertIsNone(phone("223456789012"))  # 12 digits not valid
+
+    def test_day_of_week(self):
+        self.assertEqual(day_of_week("monday"), 1)
+        self.assertEqual(day_of_week("Mon"), 1)
+        self.assertEqual(day_of_week("TUESDAY"), 2)
+        self.assertIsNone(day_of_week("xyz"))
+        self.assertIsNone(day_of_week(""))
+
+    def test_date_converter(self):
+        self.assertEqual(date_conv("2025-03-07"), date(2025, 3, 7))
+        self.assertIsNone(date_conv("2025-99-99"))
+        self.assertIsNone(date_conv("None"))
+        self.assertIsNone(date_conv("@null"))
+        # Test custom format
+        self.assertEqual(date_conv("03/07/2025", fmt="%m/%d/%Y"), date(2025, 3, 7))
+
+    def test_time_converter(self):
+        self.assertEqual(time_conv("12:34:56"), time(12, 34, 56))
+        self.assertIsNone(time_conv("None"))
+        self.assertIsNone(time_conv("25:99:99"))
+        # Test custom format
+        self.assertEqual(time_conv("01-02-03", fmt="%H-%M-%S"), time(1, 2, 3))
+
+    def test_timestamp(self):
+        self.assertEqual(
+            timestamp("2025-03-07 12:34:56"),
+            datetime(2025, 3, 7, 12, 34, 56),
+        )
+        self.assertIsNone(timestamp("2025-99-99 12:34:56"))
+        self.assertIsNone(timestamp("None"))
+        # Custom format
+        self.assertEqual(
+            timestamp("03/07/2025 12|34|56", fmt="%m/%d/%Y %H|%M|%S"),
+            datetime(2025, 3, 7, 12, 34, 56),
+        )
+
+    def test_email(self):
+        self.assertIsNone(email("None"))
+        self.assertIsNone(email("not-an-email"))
+        self.assertIsNone(email("user@domain"))  # no '.' in domain
+        self.assertEqual(email("USER@DOMAIN.COM"), "user@domain.com")
+
+    def test_integer(self):
+        self.assertIsNone(integer("None"))
+        self.assertIsNone(integer(""))
+        self.assertEqual(integer("123"), 123)
+        self.assertEqual(integer("+123.45"), 123)
+        self.assertEqual(integer("-123.99"), -123)
+        self.assertIsNone(integer("123.45.67"))  # multiple decimals
+
+    def test_boolean(self):
+        self.assertFalse(boolean("false"))
+        self.assertFalse(boolean(""))
+        self.assertFalse(boolean("F"))
+        self.assertFalse(boolean("0"))
+        self.assertFalse(boolean("no"))
+        self.assertTrue(boolean("True"))
+        self.assertTrue(boolean("any-other-string"))
+        self.assertTrue(boolean(True))
+        self.assertFalse(boolean(False))
+        self.assertFalse(boolean("@null"))
+
+    def test_rot13(self):
+        self.assertIsNone(rot13("None"))
+        self.assertEqual(rot13("abc"), "nop")
+        self.assertEqual(rot13("NOP"), "ABC")
+
+    def test_pointer(self):
+        self.assertIsNone(pointer("None"))
+        self.assertIsNone(pointer("@null"))
+        self.assertIsNone(pointer("@new"))
+        self.assertIsNone(pointer("abc"))
+        self.assertEqual(pointer("123"), 123)
+        self.assertEqual(pointer("-123"), -123)
+
+    def test_money(self):
+        self.assertIsNone(money("None"))
+        self.assertIsNone(money("abc"))
+        self.assertEqual(money("$1,234.56"), Decimal("1234.56"))
+        self.assertEqual(money("-$50"), Decimal("-50"))
+        self.assertIsNone(money("123.45.67"))
+
+    def test_round_to(self):
+        # When passing data directly
+        self.assertEqual(round_to(2, "123.456"), Decimal("123.46"))
+        self.assertEqual(round_to(0, "123.56"), Decimal("124"))
+        self.assertIsNone(round_to(2, "None"))
+        self.assertIsNone(round_to(2, "abc"))
+
+        # When using as a converter function
+        round_2 = round_to(2)
+        self.assertEqual(round_2("123.456"), Decimal("123.46"))
+        self.assertIsNone(round_2("abc"))
+
+    def test_decimal_val(self):
+        self.assertIsNone(decimal_val("None"))
+        self.assertIsNone(decimal_val("abc"))
+        self.assertEqual(decimal_val("123.45"), Decimal("123.45"))
+        self.assertIsNone(decimal_val("123.45.67"))
+
+    def test_ein(self):
+        self.assertIsNone(ein("None"))
+        self.assertIsNone(ein("12345678"))  # only 8 digits
+        self.assertEqual(ein("12-3456789"), "123456789")
+        self.assertEqual(ein("123456789"), "123456789")
+
+    def test_to_list(self):
+        self.assertIsNone(to_list("None"))
+        self.assertIsNone(to_list("@null"))
+        self.assertIsNone(to_list(""))
+        # Already list
+        self.assertEqual(to_list(["a", "b"]), ["a", "b"])
+        # String that looks like a list
+        self.assertEqual(to_list("[1, 2, 3]"), [1, 2, 3])
+        # Invalid string that starts/ends with []
+        self.assertEqual(to_list("[1, x, 3]"), ["[1, x, 3]"])
+        # Single element
+        self.assertEqual(to_list("banana"), ["banana"])
+
+    def test_title(self):
+        self.assertEqual(title("hello world"), "Hello World")
+        self.assertEqual(title("HELLO WORLD"), "Hello World")
+        self.assertEqual(title(""), "")
+        self.assertEqual(title("None"), "")  # because it becomes None -> ""
+
+    def test_lower(self):
+        self.assertEqual(lower("Hello"), "hello")
+        self.assertEqual(lower(""), "")
+        self.assertEqual(lower("NONE"), "")
+        self.assertEqual(lower("XYZ"), "xyz")
+
+    def test_upper(self):
+        self.assertEqual(upper("Hello"), "HELLO")
+        self.assertEqual(upper(""), "")
+        self.assertEqual(upper("none"), "")
+        self.assertEqual(upper("xyz"), "XYZ")
+
+    def test_padding(self):
+        pad_5 = padding(5, "0")
+        self.assertIsNone(pad_5("None"))
+        self.assertEqual(pad_5("123"), "00123")
+        pad_4_star = padding(4, "*")
+        self.assertEqual(pad_4_star("AB"), "**AB")
+        self.assertIsNone(pad_4_star("None"))
+
+    def test_string(self):
+        self.assertIsNone(string("None"))
+        self.assertIsNone(string("@null"))
+        self.assertIsNone(string(""))
+        self.assertEqual(string("hello"), "hello")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/misc/tests/test_merge.py

@@ -0,0 +1,82 @@
+import unittest
+from ..merge import deep_merge
+
+
+class TestDeepMerge(unittest.TestCase):
+
+    def test_simple_merge(self):
+        """Test merging two simple dictionaries with no nested structures."""
+        d1 = {"a": 1, "b": 2}
+        d2 = {"b": 3, "c": 4}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, {"a": 1, "b": 3, "c": 4})
+
+    def test_nested_merge(self):
+        """Test merging two dictionaries with nested dictionaries."""
+        d1 = {"a": {"x": 1}, "b": 2}
+        d2 = {"a": {"y": 2}, "b": 3}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, {"a": {"x": 1, "y": 2}, "b": 3})
+
+    def test_list_merge(self):
+        """Test merging dictionaries with lists, avoiding duplicates."""
+        d1 = {"a": [1, 2], "b": 3}
+        d2 = {"a": [2, 3], "b": 4}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, {"a": [1, 2, 3], "b": 4})
+
+    def test_deeply_nested_merge(self):
+        """Test merging deeply nested dictionaries."""
+        d1 = {"a": {"b": {"c": 1}}}
+        d2 = {"a": {"b": {"d": 2}}}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, {"a": {"b": {"c": 1, "d": 2}}})
+
+    def test_update_true(self):
+        """Test updating the first dictionary in place when update=True."""
+        d1 = {"a": 1, "b": {"x": 10}}
+        d2 = {"b": {"y": 20}, "c": 3}
+        result = deep_merge(d1, d2, update=True)
+        self.assertEqual(result, {"a": 1, "b": {"x": 10, "y": 20}, "c": 3})
+        self.assertEqual(d1, result)  # d1 should be modified in place
+
+    def test_update_false(self):
+        """Test creating a new dictionary when update=False (default)."""
+        d1 = {"a": 1, "b": {"x": 10}}
+        d2 = {"b": {"y": 20}, "c": 3}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, {"a": 1, "b": {"x": 10, "y": 20}, "c": 3})
+        self.assertNotEqual(d1, result)  # d1 should remain unchanged
+
+    def test_multiple_dicts(self):
+        """Test merging multiple dictionaries."""
+        d1 = {"a": 1}
+        d2 = {"b": 2}
+        d3 = {"c": 3}
+        result = deep_merge(d1, d2, d3)
+        self.assertEqual(result, {"a": 1, "b": 2, "c": 3})
+
+    def test_conflicting_types(self):
+        """Test conflicting types (list vs. dict), where latter overrides former."""
+        d1 = {"a": {"x": 1}}
+        d2 = {"a": [1, 2, 3]}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, {"a": [1, 2, 3]})  # d2 overrides d1 here
+
+    def test_empty_dict(self):
+        """Test merging with an empty dictionary."""
+        d1 = {"a": 1, "b": {"x": 10}}
+        d2 = {}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, d1)  # merging with empty dict should not change d1
+
+    def test_merge_with_none(self):
+        """Test merging where one dictionary has None values."""
+        d1 = {"a": 1, "b": None}
+        d2 = {"b": 2, "c": None}
+        result = deep_merge(d1, d2)
+        self.assertEqual(result, {"a": 1, "b": 2, "c": None})
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/misc/tests/test_oconv.py

@@ -0,0 +1,144 @@
+import unittest
+import datetime
+from ..conv.oconv import (
+    none,
+    phone,
+    day_of_week,
+    date_conv,
+    time_conv,
+    timestamp,
+    email,
+    pointer,
+    rot13,
+    boolean,
+    money,
+    round_to,
+    ein,
+    to_list,
+    title,
+    lower,
+    upper,
+    padding,
+    pprint,
+    string,
+)
+
+
+class TestOconvFunctions(unittest.TestCase):
+
+    def test_none(self):
+        self.assertEqual(none("null"), "")
+        self.assertEqual(none("None"), "")
+        self.assertEqual(none(""), "")
+        self.assertEqual(none("valid"), "valid")
+
+    def test_phone(self):
+        self.assertEqual(phone("123-456-7890"), "(123) 456-7890")
+        self.assertEqual(phone("(123)4567890"), "(123) 456-7890")
+        self.assertEqual(phone("invalid"), "")
+        self.assertEqual(phone(None), "")
+
+    def test_day_of_week(self):
+        self.assertEqual(day_of_week(1), "Monday")
+        self.assertEqual(day_of_week("2"), "Tuesday")
+        self.assertEqual(day_of_week(5, abbrev=True), "Fri")
+        self.assertEqual(day_of_week([1, 2, 5], abbrev=True), "Mon,Tue,Fri")
+        self.assertEqual(day_of_week("invalid"), "")
+
+    def test_date_conv(self):
+        """Tests the date_conv function with various inputs."""
+        self.assertEqual(date_conv(datetime.datetime(2023, 1, 1)), "2023-01-01")
+        self.assertEqual(date_conv(datetime.date(2023, 1, 1)), "2023-01-01")
+        self.assertEqual(date_conv("not a date"), "not a date")
+
+    def test_time_conv(self):
+        """Tests the time_conv function with various inputs."""
+        self.assertEqual(
+            time_conv(datetime.datetime(2023, 1, 1, 12, 30, 45)), "12:30:45"
+        )
+        self.assertEqual(time_conv(datetime.time(12, 30, 45)), "12:30:45")
+        self.assertEqual(time_conv("invalid"), "invalid")
+
+    def test_timestamp(self):
+        self.assertEqual(
+            timestamp(datetime.datetime(2023, 1, 1, 12, 30, 45)),
+            "Sun Jan  1 12:30:45 2023",
+        )
+        self.assertEqual(timestamp("invalid"), "invalid")
+
+    def test_email(self):
+        self.assertEqual(email("EXAMPLE@domain.com"), "example@domain.com")
+        self.assertEqual(email("None"), "")
+        self.assertEqual(email(None), "")
+
+    def test_pointer(self):
+        self.assertEqual(pointer("123"), 123)
+        self.assertEqual(pointer("invalid"), "")
+        self.assertEqual(pointer(None), "")
+
+    def test_rot13(self):
+        self.assertEqual(rot13("hello"), "uryyb")
+        self.assertEqual(rot13("uryyb"), "hello")
+
+    def test_boolean(self):
+        self.assertFalse(boolean("false"))
+        self.assertTrue(boolean("true"))
+        self.assertTrue(boolean(True))
+        self.assertFalse(boolean(False))
+
+    def test_money(self):
+        self.assertEqual(money("1234.5"), "$1,234.50")
+        self.assertEqual(money("-1234.56"), "-$1,234.56")
+        self.assertEqual(money("None"), "")
+        self.assertEqual(money(None), "")
+
+    def test_round_to(self):
+        self.assertEqual(round_to(2, "123.456"), "123.46")
+        self.assertEqual(round_to(1, "123.456"), "123.5")
+        round_func = round_to(1)
+        self.assertEqual(round_func("123.45"), "123.5")
+
+    def test_ein(self):
+        self.assertEqual(ein("123456789"), "12-3456789")
+        self.assertEqual(ein("12-3456789"), "12-3456789")
+        self.assertEqual(ein("invalid"), "")
+
+    def test_to_list(self):
+        self.assertEqual(to_list("[1, 2, 3]"), [1, 2, 3])
+        self.assertEqual(to_list("single"), ["single"])
+        self.assertEqual(to_list(["already", "a", "list"]), ["already", "a", "list"])
+        self.assertIsNone(to_list("None"))
+
+    def test_title(self):
+        self.assertEqual(title("hello world"), "Hello World")
+        self.assertEqual(title("None"), "")
+        self.assertEqual(title(None), "")
+
+    def test_lower(self):
+        self.assertEqual(lower("HELLO"), "hello")
+        self.assertEqual(lower("None"), "")
+        self.assertEqual(lower(None), "")
+
+    def test_upper(self):
+        self.assertEqual(upper("hello"), "HELLO")
+        self.assertEqual(upper("None"), "")
+        self.assertEqual(upper(None), "")
+
+    def test_padding(self):
+        pad_func = padding(10, " ")
+        self.assertEqual(pad_func("123"), "       123")
+        self.assertEqual(pad_func(None), "")
+        self.assertEqual(padding(5, "0")("12"), "00012")
+
+    def test_pprint(self):
+        self.assertEqual(pprint("[1, 2, 3]"), "[1, 2, 3]")
+        self.assertEqual(pprint("invalid"), "invalid")
+
+    def test_string(self):
+        self.assertEqual(string("text"), "text")
+        self.assertEqual(string(None), "")
+        self.assertEqual(string(""), "")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/misc/tests/test_original_error.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+
+# Test script to demonstrate the original error
+
+
+def test_original_error():
+    """Demonstrate the original error that was happening"""
+
+    # Simulate what duplicate_rows() was returning (individual dicts, not groups)
+    # The code was expecting groups but getting individual rows
+    fake_groups = [
+        {
+            "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,
+        },
+    ]
+
+    print("Testing original problematic code pattern:")
+
+    for group in fake_groups:  # group is actually a single row/dict
+        print(f"Processing 'group': {group}")
+        try:
+            # This is the line that was failing: sorted(group, key=lambda x: x["expiration_date"])
+            # When group is a dict, sorted() iterates over the keys (strings), not the values
+            sorted_group = sorted(group, key=lambda x: x["expiration_date"])
+            print(f"  Sorted result: {sorted_group}")
+        except TypeError as e:
+            print(f"  ERROR: {e}")
+            print(
+                f"  This happened because 'group' is a dict, so sorted() iterates over keys: {list(group.keys())}"
+            )
+            print(
+                f"  The lambda tries to access x['expiration_date'] where x is a string key, not a dict"
+            )
+            return False
+
+    return True
+
+
+if __name__ == "__main__":
+    print("Demonstrating the original error:")
+    test_original_error()

velocity/misc/tests/test_timer.py

@@ -0,0 +1,74 @@
+import unittest
+import time
+from ..timer import Timer
+
+
+class TestTimer(unittest.TestCase):
+    def test_initialization(self):
+        """Test that a Timer object is initialized with the correct label and zero elapsed time."""
+        timer = Timer("Test Timer")
+        self.assertEqual(timer._label, "Test Timer")
+        self.assertIsNotNone(timer._start)
+        self.assertEqual(timer._diff, None)
+
+    def test_start(self):
+        """Test that calling start() resets the timer's start time and clears any previous elapsed time."""
+        timer = Timer("Test Timer")
+        time.sleep(0.1)
+        timer.stop()
+        initial_diff = timer._diff
+
+        timer.start()
+        self.assertEqual(timer._diff, None)  # _diff should be reset
+        self.assertNotEqual(timer._start, None)  # start time should be reset
+        self.assertLess(
+            timer.elapsed(), initial_diff
+        )  # elapsed time should be smaller after restart
+
+    def test_stop(self):
+        """Test that stop() records the correct elapsed time."""
+        timer = Timer("Test Timer")
+        time.sleep(0.1)
+        timer.stop()
+        self.assertGreater(timer._diff, 0)
+        self.assertAlmostEqual(
+            timer._diff, timer.elapsed(), delta=0.01
+        )  # check recorded time
+
+    def test_elapsed_during_run(self):
+        """Test that elapsed() shows increasing time while the timer is running."""
+        timer = Timer("Test Timer")
+        time.sleep(0.1)
+        elapsed_1 = timer.elapsed()
+        time.sleep(0.1)
+        elapsed_2 = timer.elapsed()
+        self.assertGreater(elapsed_2, elapsed_1)  # time should increase while running
+
+    def test_str_running_timer(self):
+        """Test the __str__ representation while the timer is running."""
+        timer = Timer("Running Timer")
+        time.sleep(0.1)
+        output = str(timer)
+        self.assertIn("Running Timer:", output)
+        self.assertIn("s", output)  # Should include seconds in the output
+
+    def test_str_stopped_timer(self):
+        """Test the __str__ representation after stopping the timer."""
+        timer = Timer("Stopped Timer")
+        time.sleep(0.1)
+        timer.stop()
+        output = str(timer)
+        self.assertIn("Stopped Timer:", output)
+        self.assertIn("s", output)  # Should include seconds in the output
+        self.assertEqual(float(output.split(": ")[1][:-2]), float(f"{timer._diff:.4f}"))
+
+    def test_stop_without_start_error(self):
+        """Test that stopping a timer without starting it does not raise errors."""
+        timer = Timer("Test Timer")
+        timer.start()  # reset start
+        timer.stop()
+        self.assertGreater(timer._diff, 0)  # timer should stop correctly
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/misc/tools.py

@@ -1,5 +1,4 @@
 import os
-import inspect
 import hashlib
 
 

{velocity_python-0.0.109.dist-info → velocity_python-0.0.161.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.109
+Version: 0.0.161
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -497,7 +497,7 @@ def update_user(tx):
     # Find and update using dictionary syntax
     user = users.find(123)  # Returns a row that behaves like a dict
     user['name'] = 'Updated Name'         # Direct assignment like a dict
-    user['updated_at'] = datetime.now()   # No special methods needed
+    user['important_date'] = datetime.now()   # No special methods needed
     
     # Check if columns exist before updating
     if 'phone' in user: