velocity-python 0.0.32__tar.gz → 0.0.34__tar.gz

{velocity_python-0.0.32 → velocity_python-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: velocity-python
-Version: 0.0.32
+Version: 0.0.34
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Paul Perez <pperez@codeclubs.org>
 Project-URL: Homepage, https://codeclubs.org/projects/velocity

{velocity_python-0.0.32 → velocity_python-0.0.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "velocity-python"
-version = "0.0.32"
+version = "0.0.34"
 authors = [
   { name="Paul Perez", email="pperez@codeclubs.org" },
 ]

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.32"
+__version__ = version = "0.0.34"
 
 from . import aws
 from . import db

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/db/core/decorators.py

@@ -1,5 +1,6 @@
 from functools import wraps
 from velocity.db import exceptions
+import traceback
 
 
 def retry_on_dup_key(function):
@@ -55,6 +56,7 @@ def return_default(
                 if result is None:
                     result = default
             except f.exceptions as e:
+                traceback.print_exc()
                 self.tx.rollback_savepoint(sp, cursor=self.cursor)
                 return f.default
             self.tx.release_savepoint(sp, cursor=self.cursor)

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/db/core/engine.py

@@ -169,6 +169,8 @@ class Engine(object):
                     return function(*args, **kwds)
                 except exceptions.DbRetryTransaction as e:
                     if e.args and e.args[0]:
+                        print(e)
+                        print("**Retry Transaction. Rollback and start over")
                         _tx.rollback()
                         continue
                     retry_count += 1
@@ -249,6 +251,7 @@ class Engine(object):
             conf["database"] = database
         if "dbname" in conf:
             conf["dbname"] = database
+
         return self
 
     def set_config(self, config):

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/db/core/table.py

@@ -1,3 +1,4 @@
+# table.py
 from velocity.db import exceptions
 from velocity.db.core.row import Row
 from velocity.db.core.result import Result
@@ -9,8 +10,13 @@ from velocity.db.core.decorators import (
 )
 
 
-class Query(str):
-    pass
+class Query:
+    def __init__(self, sql, params=()):
+        self.sql = sql
+        self.params = params
+
+    def __str__(self):
+        return self.sql
 
 
 class Table(object):

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/db/core/transaction.py

@@ -6,6 +6,7 @@ from velocity.db.core.column import Column
 from velocity.db.core.database import Database
 from velocity.db.core.sequence import Sequence
 from velocity.misc.db import randomword
+import traceback
 
 
 debug = False
@@ -29,6 +30,11 @@ class Transaction(object):
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_type:
+            if debug:
+                print("Transaction.__exit__")
+            tb_str = "".join(traceback.format_exception(exc_type, exc_val, exc_tb))
+            if debug:
+                print(tb_str)
             self.rollback()
         self.close()
 
@@ -206,3 +212,10 @@ class Transaction(object):
             result = self.execute(sql, vals)
             self.__pg_types = dict(result.as_tuple())
         return self.__pg_types
+
+    def switch_to_database(self, name):
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+        self.engine.switch_to_database(name)
+        return self

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/db/servers/postgres.py

@@ -445,7 +445,7 @@ class SQL(object):
         trigger = "".format(name)
         sql = []
         if drop:
-            sql.append(cls.drop_table(fqtn))
+            sql.append(cls.drop_table(fqtn)[0])
         sql.append(
             """
             CREATE TABLE {0} (

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/misc/conv/iconv.py

@@ -83,7 +83,11 @@ def email(data: str) -> Optional[str]:
 
 def integer(data: str) -> int:
     """Converts a string to an integer, removing non-numeric characters."""
-    return int(re.sub(r"[^0-9\.-]", "", data))
+    cleaned_data = re.sub(r"[^0-9\.-]", "", data)
+    try:
+        return int(float(cleaned_data))
+    except ValueError:
+        raise ValueError(f"Cannot convert {data} to integer.")
 
 
 def boolean(data: Union[str, bool]) -> bool:

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity/misc/conv/oconv.py

@@ -1,9 +1,11 @@
+# oconv.py
 import re
 import codecs
 import decimal
-from datetime import datetime, date, time
+import datetime
 from pprint import pformat
 from typing import Optional, Union, List, Callable
+import ast
 
 # Convert SQL data to JS format for display
 
@@ -36,7 +38,15 @@ def day_of_week(data: Union[int, str, List], abbrev: bool = False) -> str:
         6: "Saturday",
         7: "Sunday",
     }
-    days_abbrev = {1: "Mon", 2: "Tue", 3: "Wed", 4: "Thu", 5: "Fri", 6: "Sat", 7: "Sun"}
+    days_abbrev = {
+        1: "Mon",
+        2: "Tue",
+        3: "Wed",
+        4: "Thu",
+        5: "Fri",
+        6: "Sat",
+        7: "Sun",
+    }
     days = days_abbrev if abbrev else days_full
 
     if isinstance(data, list):
@@ -48,19 +58,29 @@ def day_of_week(data: Union[int, str, List], abbrev: bool = False) -> str:
         return ""
 
 
-def date(data: Union[datetime, date, str], fmt: str = "%Y-%m-%d") -> str:
+def date(
+    data: Union[datetime.datetime, datetime.date, str], fmt: str = "%Y-%m-%d"
+) -> str:
     """Formats a date object as a string according to the specified format."""
-    return data.strftime(fmt) if isinstance(data, (datetime, date)) else str(data)
+    return (
+        data.strftime(fmt)
+        if isinstance(data, (datetime.datetime, datetime.date))
+        else str(data)
+    )
 
 
-def time(data: Union[datetime, time, str], fmt: str = "%X") -> str:
+def time(data: Union[datetime.datetime, datetime.time, str], fmt: str = "%X") -> str:
     """Formats a time object as a string according to the specified format."""
-    return data.strftime(fmt) if isinstance(data, (datetime, time)) else str(data)
+    return (
+        data.strftime(fmt)
+        if isinstance(data, (datetime.datetime, datetime.time))
+        else str(data)
+    )
 
 
-def timestamp(data: Union[datetime, str], fmt: str = "%c") -> str:
+def timestamp(data: Union[datetime.datetime, str], fmt: str = "%c") -> str:
     """Formats a datetime object as a string according to the specified format."""
-    return data.strftime(fmt) if isinstance(data, datetime) else str(data)
+    return data.strftime(fmt) if isinstance(data, datetime.datetime) else str(data)
 
 
 def email(data: Optional[str]) -> str:
@@ -88,24 +108,29 @@ def boolean(data: Union[str, bool]) -> bool:
     return bool(data)
 
 
-def money(data: str) -> str:
-    """Formats a numeric string as currency."""
+def money(data: Union[str, float, int, decimal.Decimal]) -> str:
+    """Formats a numeric value as currency."""
     if data in [None, ""]:
         return ""
-    cleaned_data = re.sub(r"[^0-9\.-]", "", str(data))
-    return f"${decimal.Decimal(cleaned_data):,.2f}"
+    try:
+        amount = decimal.Decimal(str(data))
+        return f"${amount:,.2f}"
+    except (decimal.InvalidOperation, ValueError):
+        return ""
 
 
 def round_to(
     precision: int, data: Optional[Union[str, float, decimal.Decimal]] = None
-) -> Union[Callable, str]:
+) -> Union[Callable[[Union[str, float, decimal.Decimal]], str], str]:
     """Rounds a number to the specified precision."""
 
     def function(value):
-        cleaned_value = re.sub(r"[^0-9\.-]", "", str(value))
-        return (
-            f"{decimal.Decimal(cleaned_value):.{precision}f}" if cleaned_value else "0"
-        )
+        try:
+            amount = decimal.Decimal(str(value))
+            rounded = round(amount, precision)
+            return f"{rounded:.{precision}f}"
+        except (decimal.InvalidOperation, ValueError):
+            return "0"
 
     return function if data is None else function(data)
 
@@ -125,11 +150,15 @@ def to_list(data: Union[str, List]) -> Optional[List]:
         return None
     if isinstance(data, list):
         return data
-    if isinstance(data, str) and data.startswith("["):
-        try:
-            return eval(data)  # Be cautious with eval; only use if data is trusted
-        except (SyntaxError, NameError):
-            return None
+    if isinstance(data, str):
+        data = data.strip()
+        if data.startswith("[") and data.endswith("]"):
+            try:
+                return ast.literal_eval(data)
+            except (SyntaxError, ValueError):
+                return None
+        else:
+            return [data]
     return [data]
 
 
@@ -160,8 +189,9 @@ def padding(length: int, char: str) -> Callable[[str], str]:
 def pprint(data: str) -> str:
     """Pretty-prints a JSON-like string representation of data."""
     try:
-        return pformat(eval(data))
-    except (SyntaxError, NameError):
+        parsed_data = ast.literal_eval(data)
+        return pformat(parsed_data)
+    except (SyntaxError, ValueError):
         return data
 
 

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: velocity-python
-Version: 0.0.32
+Version: 0.0.34
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Paul Perez <pperez@codeclubs.org>
 Project-URL: Homepage, https://codeclubs.org/projects/velocity

{velocity_python-0.0.32 → velocity_python-0.0.34}/src/velocity_python.egg-info/SOURCES.txt

@@ -42,11 +42,13 @@ src/velocity_python.egg-info/requires.txt
 src/velocity_python.egg-info/top_level.txt
 tests/test_db.py
 tests/test_email_processing.py
+tests/test_foreign_key_handling.py
 tests/test_format.py
 tests/test_iconv.py
 tests/test_merge.py
 tests/test_oconv.py
 tests/test_postgres.py
+tests/test_postgres_advanced.py
 tests/test_response.py
 tests/test_spreadsheet_functions.py
 tests/test_timer.py

velocity_python-0.0.34/tests/test_foreign_key_handling.py

@@ -0,0 +1,169 @@
+import unittest
+from velocity.db.servers import postgres
+
+test_db = "test_foreign_key_db"
+engine = postgres.initialize(database=test_db)
+
+
+@engine.transaction
+class TestForeignKeyHandling(unittest.TestCase):
+    @classmethod
+    @engine.transaction
+    def setUpClass(cls, tx):
+        # Drop and recreate the test database
+        tx.switch_to_database("postgres")
+        tx.execute(f"drop database if exists {test_db}", single=True)
+        tx.execute(f"create database {test_db}", single=True)
+        tx.switch_to_database(test_db)
+
+        # Create parent_table
+        parent_table = tx.table("parent_table")
+        parent_table.create(
+            columns={
+                "name": str,
+            }
+        )
+
+        # Create middle_table with a foreign key to parent_table
+        middle_table = tx.table("middle_table")
+        middle_table.create(
+            columns={
+                "parent_id": int,
+                "title": str,
+            }
+        )
+        middle_table.create_foreign_key("parent_id", "parent_table", "sys_id")
+
+        # Create child_table with foreign keys to both parent_table and middle_table
+        child_table = tx.table("child_table")
+        child_table.create(
+            columns={
+                "parent_id": int,
+                "middle_id": int,
+            }
+        )
+        child_table.create_foreign_key("parent_id", "parent_table", "sys_id")
+        child_table.create_foreign_key("middle_id", "middle_table", "sys_id")
+
+    @classmethod
+    @engine.transaction
+    def tearDownClass(cls, tx):
+        # Drop the test database
+        # tx.switch_to_database("postgres")
+        # tx.execute(f"drop database if exists {test_db}", single=True)
+        pass
+
+    def test_foreign_key_with_specified_sys_id(self, tx):
+        # Insert data into parent_table with specified sys_id
+        parent_table = tx.table("parent_table")
+        parent_table.insert({"sys_id": 100, "name": "Parent 1"})
+        parent_table.insert({"sys_id": 200, "name": "Parent 2"})
+
+        # Insert data into middle_table with specified sys_id
+        middle_table = tx.table("middle_table")
+        middle_table.insert({"sys_id": 300, "parent_id": 100, "title": "Title 1"})
+        middle_table.insert({"sys_id": 400, "parent_id": 200, "title": "Title 2"})
+
+        # Insert data into child_table with specified sys_id
+        child_table = tx.table("child_table")
+        child_table.insert(
+            {
+                "sys_id": 500,
+                "parent_id": 100,
+                "middle_id": 300,
+                "description": "Child A",
+            }
+        )
+        child_table.insert(
+            {
+                "sys_id": 600,
+                "parent_id": 200,
+                "middle_id": 400,
+                "description": "Child B",
+            }
+        )
+
+        # Query selecting columns with three foreign key references
+        result = list(
+            child_table.select(
+                columns=[
+                    "parent_id>name",
+                    "middle_id>title",
+                    "sys_id",
+                    "description",
+                ]
+            )
+        )
+        expected_result = [
+            {
+                "parent_id_name": "Parent 1",
+                "middle_id_title": "Title 1",
+                "sys_id": 500,
+                "description": "Child A",
+            },
+            {
+                "parent_id_name": "Parent 2",
+                "middle_id_title": "Title 2",
+                "sys_id": 600,
+                "description": "Child B",
+            },
+        ]
+        self.assertEqual(result, expected_result)
+
+    def test_foreign_key_conditions_with_specified_sys_id(self, tx):
+        # Query with conditions on foreign key references
+        child_table = tx.table("child_table")
+        result = list(
+            child_table.select(
+                columns=[
+                    "parent_id>name",
+                    "middle_id>title",
+                    "sys_id",
+                    "description",
+                ],
+                where={"parent_id>name": "Parent 1", "middle_id>title": "Title 1"},
+            )
+        )
+        expected_result = [
+            {
+                "parent_id_name": "Parent 1",
+                "middle_id_title": "Title 1",
+                "sys_id": 500,
+                "description": "Child A",
+            }
+        ]
+        self.assertEqual(result, expected_result)
+
+    def test_foreign_key_ordering_with_specified_sys_id(self, tx):
+        # Query with ordering based on foreign key references
+        child_table = tx.table("child_table")
+        result = list(
+            child_table.select(
+                columns=[
+                    "parent_id>name",
+                    "middle_id>title",
+                    "sys_id",
+                    "description",
+                ],
+                orderby="parent_id>name DESC, middle_id>title ASC",
+            )
+        )
+        expected_result = [
+            {
+                "parent_id_name": "Parent 2",
+                "middle_id_title": "Title 2",
+                "sys_id": 600,
+                "description": "Child B",
+            },
+            {
+                "parent_id_name": "Parent 1",
+                "middle_id_title": "Title 1",
+                "sys_id": 500,
+                "description": "Child A",
+            },
+        ]
+        self.assertEqual(result, expected_result)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.0.34/tests/test_iconv.py

@@ -0,0 +1,207 @@
+# test_iconv.py
+import unittest
+import re
+import codecs
+from decimal import Decimal, InvalidOperation
+from datetime import datetime, date, time
+from typing import Optional, Union, Callable
+from velocity.misc.conv.iconv import (
+    none,
+    phone,
+    day_of_week,
+    date as date_func,
+    time as time_func,
+    timestamp,
+    email,
+    integer,
+    boolean,
+    rot13,
+    pointer,
+    money,
+    round_to,
+    decimal as decimal_func,
+    ein,
+    to_list,
+    title,
+    lower,
+    upper,
+    padding,
+    string,
+)
+
+
+class TestIconvModule(unittest.TestCase):
+
+    def test_none(self):
+        self.assertIsNone(none(""))
+        self.assertIsNone(none("null"))
+        self.assertIsNone(none("None"))
+        self.assertIsNone(none("@NULL"))
+        self.assertEqual(none("value"), "value")
+
+    def test_phone(self):
+        self.assertEqual(phone("123-456-7890"), "1234567890")
+        self.assertEqual(phone("(123) 456-7890"), "1234567890")
+        self.assertIsNone(phone("12345"))
+        self.assertIsNone(phone(None))
+        self.assertIsNone(phone("None"))
+
+    def test_day_of_week(self):
+        self.assertEqual(day_of_week("Monday"), 1)
+        self.assertEqual(day_of_week("fri"), 5)
+        self.assertIsNone(day_of_week("Funday"))
+        self.assertIsNone(day_of_week(""))
+        self.assertIsNone(day_of_week(None))
+
+    def test_date(self):
+        self.assertEqual(date_func("2023-01-01"), date(2023, 1, 1))
+        self.assertIsNone(date_func("2023/01/01"))
+        self.assertIsNone(date_func(""))
+        self.assertIsNone(date_func(None))
+        self.assertEqual(date_func("01-02-2023", fmt="%d-%m-%Y"), date(2023, 2, 1))
+
+    def test_time(self):
+        self.assertEqual(time_func("23:59:59"), time(23, 59, 59))
+        self.assertIsNone(time_func("24:00:00"))
+        self.assertIsNone(time_func(""))
+        self.assertIsNone(time_func(None))
+        self.assertEqual(time_func("11:30 PM", fmt="%I:%M %p"), time(23, 30))
+
+    def test_timestamp(self):
+        self.assertEqual(
+            timestamp("01 Jan 23 12:34:56", fmt="%d %b %y %H:%M:%S"),
+            datetime(2023, 1, 1, 12, 34, 56),
+        )
+        self.assertIsNone(timestamp("Invalid date"))
+        self.assertIsNone(timestamp(""))
+        self.assertIsNone(timestamp(None))
+
+    def test_email(self):
+        self.assertEqual(email("Test@Example.com"), "test@example.com")
+        self.assertEqual(
+            email("  user.name+tag+sorting@example.com  "),
+            "user.name+tag+sorting@example.com",
+        )
+        self.assertIsNone(email(None))
+        self.assertIsNone(email("None"))
+        with self.assertRaises(ValueError):
+            email("invalid-email")
+
+    def test_integer(self):
+        self.assertEqual(integer("123"), 123)
+        self.assertEqual(integer("-123"), -123)
+        self.assertEqual(integer("1,234"), 1234)
+        self.assertEqual(integer("$1,234.56"), 1234)
+        self.assertEqual(integer("abc123xyz"), 123)
+        with self.assertRaises(ValueError):
+            integer("abc")
+
+    def test_boolean(self):
+        self.assertFalse(boolean(""))
+        self.assertFalse(boolean("false"))
+        self.assertFalse(boolean("False"))
+        self.assertFalse(boolean("f"))
+        self.assertFalse(boolean("off"))
+        self.assertFalse(boolean("no"))
+        self.assertTrue(boolean("True"))
+        self.assertTrue(boolean("yes"))
+        self.assertTrue(boolean(True))
+        self.assertFalse(boolean(False))
+
+    def test_rot13(self):
+        self.assertEqual(rot13("Hello"), "Uryyb")
+        self.assertEqual(rot13("Uryyb"), "Hello")
+        self.assertEqual(rot13(""), "")
+        self.assertEqual(
+            rot13("Gur Dhvpx Oebja Sbk Whzcf Bire Gur Ynml Qbt."),
+            "The Quick Brown Fox Jumps Over The Lazy Dog.",
+        )
+
+    def test_pointer(self):
+        self.assertIsNone(pointer("@new"))
+        self.assertIsNone(pointer("@NULL"))
+        self.assertIsNone(pointer(None))
+        self.assertIsNone(pointer(""))
+        self.assertEqual(pointer("123"), 123)
+        self.assertEqual(pointer(456), 456)
+        with self.assertRaises(ValueError):
+            pointer("abc")
+
+    def test_money(self):
+        self.assertEqual(money("$1,234.56"), Decimal("1234.56"))
+        self.assertEqual(money("-$1,234.56"), Decimal("-1234.56"))
+        self.assertIsNone(money("None"))
+        self.assertIsNone(money(None))
+        with self.assertRaises(InvalidOperation):
+            money("Invalid")
+
+    def test_round_to(self):
+        func = round_to(2)
+        self.assertEqual(func("123.456"), Decimal("123.46"))
+        self.assertEqual(func(Decimal("123.451")), Decimal("123.45"))
+        self.assertIsNone(func(None))
+        self.assertEqual(round_to(2, "123.456"), Decimal("123.46"))
+
+    def test_decimal(self):
+        self.assertEqual(decimal_func("123.456"), Decimal("123.456"))
+        self.assertEqual(decimal_func("$1,234.56"), Decimal("1234.56"))
+        self.assertIsNone(decimal_func("None"))
+        self.assertIsNone(decimal_func(None))
+        with self.assertRaises(InvalidOperation):
+            decimal_func("Invalid")
+
+    def test_ein(self):
+        self.assertEqual(ein("12-3456789"), "123456789")
+        self.assertEqual(ein("123456789"), "123456789")
+        self.assertIsNone(ein("123-45-6789"))
+        self.assertIsNone(ein("12345678"))
+        self.assertIsNone(ein(None))
+        self.assertIsNone(ein("None"))
+
+    def test_to_list(self):
+        self.assertEqual(to_list("[1, 2, 3]"), [1, 2, 3])
+        self.assertEqual(to_list("['a', 'b', 'c']"), ["a", "b", "c"])
+        self.assertEqual(to_list("value"), ["value"])
+        self.assertEqual(to_list(["value1", "value2"]), ["value1", "value2"])
+        self.assertIsNone(to_list(None))
+        self.assertIsNone(to_list("None"))
+        # Test with potential security risk input
+        with self.assertRaises(SyntaxError):
+            to_list("__import__('os').system('echo dangerous')")
+
+    def test_title(self):
+        self.assertEqual(title("hello world"), "Hello World")
+        self.assertEqual(title("TEST"), "Test")
+        self.assertEqual(title(None), "")
+        self.assertEqual(title("None"), "")
+
+    def test_lower(self):
+        self.assertEqual(lower("Hello World"), "hello world")
+        self.assertEqual(lower("TEST"), "test")
+        self.assertEqual(lower(None), "")
+        self.assertEqual(lower("None"), "")
+
+    def test_upper(self):
+        self.assertEqual(upper("Hello World"), "HELLO WORLD")
+        self.assertEqual(upper("test"), "TEST")
+        self.assertEqual(upper(None), "")
+        self.assertEqual(upper("None"), "")
+
+    def test_padding(self):
+        pad_func = padding(5)
+        self.assertEqual(pad_func("1"), "    1")
+        self.assertEqual(pad_func("12345"), "12345")
+        self.assertEqual(pad_func("123456"), "123456")
+        self.assertIsNone(pad_func(None))
+        self.assertIsNone(pad_func(""))
+        pad_func_char = padding(5, "0")
+        self.assertEqual(pad_func_char("1"), "00001")
+
+    def test_string(self):
+        self.assertEqual(string("value"), "value")
+        self.assertIsNone(string(""))
+        self.assertEqual(string(None), None)
+
+
+if __name__ == "__main__":
+    unittest.main()

{velocity_python-0.0.32 → velocity_python-0.0.34}/tests/test_postgres.py

@@ -1,5 +1,6 @@
 import unittest
-from your_module import (
+import decimal
+from velocity.db.servers.postgres import (
     make_where,
     quote,
     SQL,

velocity_python-0.0.34/tests/test_postgres_advanced.py

@@ -0,0 +1,273 @@
+import unittest
+import datetime
+import decimal
+from velocity.db.servers.postgres import (
+    make_where,
+    quote,
+    SQL,
+)  # Replace 'your_module' with the actual module name
+from velocity.db.core.table import (
+    Query,
+)  # Adjust the import path according to your project structure
+
+
+class TestSQLModule(unittest.TestCase):
+    # Existing tests (as previously provided)
+    # ...
+
+    # New tests for complicated SQL edge cases
+
+    def test_make_where_with_nested_subquery(self):
+        sql = []
+        vals = []
+        subquery = Query("SELECT id FROM other_table WHERE value = %s", ("test",))
+        make_where({"id": subquery}, sql, vals)
+        self.assertEqual(
+            " ".join(sql), "WHERE id in (SELECT id FROM other_table WHERE value = %s)"
+        )
+        self.assertEqual(vals, ("test",))
+
+    def test_make_where_with_multiple_conditions(self):
+        sql = []
+        vals = []
+        where_conditions = [
+            ("column1>", 5),
+            ("column2<=", 10),
+            ("column3%", "%value%"),
+            ("column4!%", "%exclude%"),
+        ]
+        make_where(where_conditions, sql, vals)
+        expected_sql = "WHERE column1 > %s AND column2 <= %s AND column3 ilike %s AND column4 not like %s"
+        self.assertEqual(" ".join(sql), expected_sql)
+        self.assertEqual(vals, [5, 10, "%value%", "%exclude%"])
+
+    def test_make_where_with_complex_operators(self):
+        sql = []
+        vals = []
+        make_where({"column1~": "^test.*", "column2!~*": ".*exclude$"}, sql, vals)
+        self.assertEqual(" ".join(sql), "WHERE column1 ~ %s AND column2 !~* %s")
+        self.assertEqual(vals, ["^test.*", ".*exclude$"])
+
+    def test_sql_select_with_complex_join(self):
+        sql_query, params = SQL.select(
+            columns=["A.id", "B.name", "C.value"],
+            table="tableA A",
+            inner_join={"tableB B": "A.b_id = B.id", "tableC C": "B.c_id = C.id"},
+            where={"A.status": "active", "C.value>": 100},
+            orderby="C.value DESC",
+        )
+        expected_sql = (
+            "SELECT A.id,B.name,C.value FROM tableA A "
+            "INNER JOIN tableB B ON A.b_id = B.id "
+            "INNER JOIN tableC C ON B.c_id = C.id "
+            "WHERE A.status = %s AND C.value > %s ORDER BY C.value DESC"
+        )
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ("active", 100))
+
+    def test_sql_select_with_group_by_and_having(self):
+        sql_query, params = SQL.select(
+            columns="column1, COUNT(*)",
+            table="my_table",
+            groupby="column1",
+            having="COUNT(*) > 1",
+            orderby="column1 ASC",
+        )
+        expected_sql = "SELECT column1, COUNT(*) FROM my_table GROUP BY column1 HAVING COUNT(*) > 1 ORDER BY column1 ASC"
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ())
+
+    def test_sql_insert_with_special_types(self):
+        sql_query, params = SQL.insert(
+            table="my_table",
+            data={
+                "int_column": 123,
+                "decimal_column": decimal.Decimal("123.456"),
+                "datetime_column": datetime.datetime(2023, 1, 1, 12, 0),
+                "bool_column": True,
+                "text_column": "Some text",
+            },
+        )
+        self.assertIn("INSERT INTO my_table", sql_query)
+        self.assertEqual(len(params), 5)
+        self.assertIsInstance(params[1], decimal.Decimal)
+        self.assertIsInstance(params[2], datetime.datetime)
+        self.assertIsInstance(params[3], bool)
+
+    def test_sql_update_with_excluded(self):
+        sql_query, params = SQL.update(
+            table="my_table",
+            data={"column1": "value1", "column2": "value2"},
+            pk={"id": 1},
+            excluded=True,
+        )
+        expected_sql = (
+            "UPDATE SET column1 = EXCLUDED.column1,column2 = EXCLUDED.column2"
+        )
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ())
+
+    def test_sql_create_table_with_constraints(self):
+        sql_query, params = SQL.create_table(
+            name="public.test_table",
+            columns={
+                "id": "@@SERIAL PRIMARY KEY",
+                "name": str,
+                "age": int,
+                "email": "@@VARCHAR(255) UNIQUE",
+                "created_at": "@@TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+            },
+            drop=True,
+        )
+        self.assertIn("CREATE TABLE public.test_table", sql_query)
+        self.assertIn("id SERIAL PRIMARY KEY", sql_query)
+        self.assertIn("email VARCHAR(255) UNIQUE", sql_query)
+        self.assertIn("created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP", sql_query)
+        self.assertEqual(params, ())
+
+    def test_sql_create_foreign_key_with_schema(self):
+        sql_query, params = SQL.create_foreign_key(
+            table="schema.child_table",
+            columns="parent_id",
+            key_to_table="schema.parent_table",
+            key_to_columns="id",
+            schema="schema",
+        )
+        self.assertIn("ALTER TABLE schema.child_table ADD CONSTRAINT", sql_query)
+        self.assertIn("REFERENCES schema.parent_table (id);", sql_query)
+        self.assertEqual(params, ())
+
+    def test_sql_merge_with_complex_conflict_resolution(self):
+        sql_query, params = SQL.merge(
+            table="my_table",
+            data={"column1": "value1", "column2": "value2"},
+            pk={"id": 1},
+            on_conflict_do_nothing=False,
+            on_conflict_update=True,
+        )
+        self.assertIn("ON CONFLICT (id) DO UPDATE SET", sql_query)
+        self.assertIn("column1 = EXCLUDED.column1", sql_query)
+        self.assertEqual(params, ("value1", "value2"))
+
+    def test_sql_select_with_subquery_in_columns(self):
+        sql_query, params = SQL.select(
+            columns="id, (SELECT COUNT(*) FROM orders WHERE user_id = users.id) as order_count",
+            table="users",
+            where={"status": "active"},
+        )
+        expected_sql = (
+            "SELECT id, (SELECT COUNT(*) FROM orders WHERE user_id = users.id) as order_count "
+            "FROM users WHERE status = %s"
+        )
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ("active",))
+
+    def test_make_where_with_special_characters_in_values(self):
+        sql = []
+        vals = []
+        make_where({"text_column": "O'Reilly"}, sql, vals)
+        self.assertEqual(" ".join(sql), "WHERE text_column = %s")
+        self.assertEqual(vals, ["O'Reilly"])
+
+    def test_sql_update_with_complex_where(self):
+        sql_query, params = SQL.update(
+            table="my_table",
+            data={"status": "inactive"},
+            pk={"last_login<": datetime.datetime.now(), "status": "active"},
+        )
+        expected_sql = (
+            "UPDATE my_table SET status = %s WHERE last_login < %s AND status = %s"
+        )
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(len(params), 3)
+        self.assertEqual(params[0], "inactive")
+
+    def test_sql_delete_with_subquery(self):
+        subquery = Query("SELECT id FROM inactive_users", ())
+        sql_query, params = SQL.delete(table="users", where={"id": subquery})
+        expected_sql = "DELETE FROM users WHERE id in (SELECT id FROM inactive_users)"
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ())
+
+    def test_sql_select_with_offset_and_limit(self):
+        sql_query, params = SQL.select(columns="*", table="my_table", start=10, qty=20)
+        expected_sql = "SELECT * FROM my_table OFFSET 10 ROWS FETCH NEXT 20 ROWS ONLY"
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ())
+
+    def test_sql_create_index_with_trigram(self):
+        sql_query, params = SQL.create_index(
+            table="my_table", columns="text_column", trigram="GIN"
+        )
+        self.assertIn("USING GIN", sql_query)
+        self.assertIn("(text_column) gin_trgm_ops", sql_query)
+        self.assertEqual(params, ())
+
+    def test_sql_alter_table_add_column(self):
+        sql_query, params = SQL.alter_add(
+            table="my_table", columns={"new_column": str}, null_allowed=False
+        )
+        expected_sql = "ALTER TABLE my_table ADD new_column TEXT NOT NULL;"
+        self.assertEqual(sql_query.strip(), expected_sql.strip())
+        self.assertEqual(params, ())
+
+    def test_sql_alter_table_drop_column(self):
+        sql_query, params = SQL.alter_drop(
+            table="my_table", columns={"old_column": None}
+        )
+        expected_sql = "ALTER TABLE my_table DROP COLUMN old_column"
+        self.assertIn(expected_sql, sql_query)
+        self.assertEqual(params, ())
+
+    def test_sql_alter_column_type(self):
+        sql_query, params = SQL.alter_column_by_type(
+            table="my_table",
+            column="int_column",
+            value=decimal.Decimal("0.0"),
+            nullable=False,
+        )
+        expected_sql = (
+            "ALTER TABLE my_table ALTER COLUMN int_column TYPE NUMERIC(19, 6) "
+            "USING int_column::NUMERIC NOT NULL"
+        )
+        self.assertEqual(sql_query.strip(), expected_sql.strip())
+        self.assertEqual(params, ())
+
+    def test_sql_alter_column_with_sql(self):
+        sql_query, params = SQL.alter_column_by_sql(
+            table="my_table", column="text_column", value="SET DEFAULT %s"
+        )
+        expected_sql = "ALTER TABLE my_table ALTER COLUMN text_column SET DEFAULT %s"
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ())
+
+    def test_sql_duplicate_rows_detection(self):
+        sql_query, params = SQL.duplicate_rows(
+            table="my_table", columns=["column1", "column2"], where={"status": "active"}
+        )
+        expected_sql = (
+            "SELECT column1,column2 FROM my_table WHERE status = %s "
+            "GROUP BY column1,column2 HAVING count(*) > 2"
+        )
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ("active",))
+
+    def test_sql_missing_ids(self):
+        sql_query, params = SQL.missing(
+            table="my_table",
+            list=[1, 2, 3, 4, 5],
+            column="id",
+            where={"status": "active"},
+        )
+        expected_sql = (
+            "SELECT * FROM UNNEST('{1,2,3,4,5}'::int[]) id EXCEPT ALL "
+            "SELECT id FROM my_table WHERE status = %s"
+        )
+        self.assertEqual(sql_query, expected_sql)
+        self.assertEqual(params, ("active",))
+
+    # Additional edge cases can be added here
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.0.32/tests/test_iconv.py

@@ -1,141 +0,0 @@
-import unittest
-import datetime
-from velocity.misc.conv.iconv import (
-    none,
-    phone,
-    day_of_week,
-    date,
-    time,
-    timestamp,
-    email,
-    pointer,
-    rot13,
-    boolean,
-    money,
-    round_to,
-    ein,
-    to_list,
-    title,
-    lower,
-    upper,
-    padding,
-    pprint,
-    string,
-)
-
-
-class TestIconvFunctions(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("1234567890"), "(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(self):
-        self.assertEqual(date(datetime.datetime(2023, 1, 1)), "2023-01-01")
-        self.assertEqual(date(datetime.date(2023, 1, 1)), "2023-01-01")
-        self.assertEqual(date("not a date"), "not a date")
-
-    def test_time(self):
-        self.assertEqual(time(datetime.datetime(2023, 1, 1, 12, 30, 45)), "12:30:45")
-        self.assertEqual(time(datetime.time(12, 30, 45)), "12:30:45")
-        self.assertEqual(time("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()