velocity-python 0.0.66__tar.gz → 0.0.68__tar.gz

{velocity_python-0.0.66 → velocity_python-0.0.68}/PKG-INFO

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

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

{velocity_python-0.0.66 → velocity_python-0.0.68}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.66"
+__version__ = version = "0.0.68"
 
 from . import aws
 from . import db

{velocity_python-0.0.66 → velocity_python-0.0.68}/src/velocity/db/core/transaction.py

@@ -77,6 +77,7 @@ class Transaction:
 
         try:
             if parms:
+                # print(f"*** {id(self)} --> transaction.execute({sql}, {parms})")
                 cursor.execute(sql, parms)
             else:
                 cursor.execute(sql)

velocity_python-0.0.68/src/velocity/db/servers/postgres/__init__.py

@@ -0,0 +1,19 @@
+import os
+import psycopg2
+from .sql import SQL
+from velocity.db.core import engine
+
+
+def initialize(config=None, **kwargs):
+    if not config:
+        # Keep the default config inside this function.
+        config = {
+            "database": os.environ["DBDatabase"],
+            "host": os.environ["DBHost"],
+            "port": os.environ["DBPort"],
+            "user": os.environ["DBUser"],
+            "password": os.environ["DBPassword"],
+        }
+    config.update(kwargs)
+    print(config)
+    return engine.Engine(psycopg2, config, SQL)

{velocity_python-0.0.66 → velocity_python-0.0.68}/src/velocity/db/servers/postgres/sql.py

@@ -1,7 +1,7 @@
 import re
 import hashlib
 import sqlparse
-
+from psycopg2 import sql
 
 from velocity.db.core import exceptions
 
@@ -285,6 +285,20 @@ class SQL:
 
     @classmethod
     def update(cls, tx, table, data, where=None, pk=None, excluded=False):
+        """
+        Generate a Postgres UPDATE statement, handling the WHERE clause logic similar
+        to how the SELECT statement does. If you want to do an ON CONFLICT ... DO UPDATE,
+        that logic should generally live in `merge(...)` rather than here.
+
+        :param tx: Database/transaction context object (used by TableHelper)
+        :param table: Table name
+        :param data: Dictionary of columns to update
+        :param where: WHERE clause conditions (dict, list of tuples, or string)
+        :param pk: Primary key dict to merge with `where`
+        :param excluded: If True, creates `col = EXCLUDED.col` expressions (used in upsert)
+        :return: (sql_string, params_tuple)
+        """
+
         if not table:
             raise ValueError("Table name is required.")
         if not pk and not where:
@@ -293,102 +307,110 @@ class SQL:
             raise ValueError("data must be a non-empty mapping of column-value pairs.")
 
         th = TableHelper(tx, table)
-
         set_clauses = []
         vals = []
 
+        # Merge pk into where if pk is provided
         if pk:
             if where:
-                where.update(pk)
+                # If where is a dict, update it; otherwise raise error
+                if isinstance(where, Mapping):
+                    where = dict(where)  # copy to avoid mutation
+                    where.update(pk)
+                else:
+                    raise ValueError(
+                        "Cannot combine 'pk' with a non-dict 'where' clause."
+                    )
             else:
                 where = pk
 
-        # Handle data columns (SET clause)
+        # Build SET clauses
         for col, val in data.items():
-            col = th.resolve_references(
+            col_quoted = th.resolve_references(
                 col, options={"alias_column": False, "alias_table": False}
             )
-
-            # Normal column
             if excluded:
-                set_clauses.append(f"{col} = EXCLUDED.{col}")
+                # For ON CONFLICT DO UPDATE statements, use the EXCLUDED value
+                set_clauses.append(f"{col_quoted} = EXCLUDED.{col_quoted}")
             else:
-                set_clauses.append(f"{col} = %s")
+                set_clauses.append(f"{col_quoted} = %s")
                 vals.append(val)
 
-        # Extract the final where conditions and values
+        # Build WHERE clauses for a normal update (ignored when excluded is True)
         where_clauses = []
         if not excluded:
-            # First handle user-provided WHERE conditions
-            if isinstance(where, Mapping):
-                for key, val in where.items():
-                    col, value = th.make_predicate(key, val)
-                    where_clauses.append(col)
-                    if isinstance(value, tuple):
-                        vals.extend(value)
-                    else:
-                        vals.append(value)
-
-        # Final assembly of SQL
-        sql = []
-        sql.append("UPDATE")
-        if not excluded:
-            if th.foreign_keys:
-                sql.append(
-                    f"{th.quote(table)} AS {th.quote(th.get_table_alias('current_table'))}"
+            if where:
+                if isinstance(where, Mapping):
+                    new_where = []
+                    for key, val in where.items():
+                        new_where.append(th.make_predicate(key, val))
+                    where = new_where
+                if isinstance(where, str):
+                    where_clauses.append(where)
+                else:
+                    for pred, value in where:
+                        where_clauses.append(pred)
+                        if value is None:
+                            pass
+                        elif isinstance(value, tuple):
+                            vals.extend(value)
+                        else:
+                            vals.append(value)
+            if not where_clauses:
+                raise ValueError(
+                    "No WHERE clause could be constructed. Update would affect all rows."
                 )
-            else:
-                sql.append(TableHelper.quote(table))
-        sql.append("SET " + ", ".join(set_clauses))
-        if not excluded:
-            if th.foreign_keys:
-                for key, ref_info in th.foreign_keys.items():
-                    ref_table = ref_info["ref_table"]
-                    sql.append(
-                        f"LEFT JOIN {th.quote(ref_table)} AS {th.quote(ref_info['alias'])} "
-                    )
-                    where_clauses.append(
-                        f"{th.quote(th.get_table_alias('current_table'))}.{th.quote(ref_info['local_column'])} = {th.quote(ref_info['alias'])}.{th.quote(ref_info['ref_column'])}"
-                    )
 
-        if not excluded:
+        # Construct final SQL
+        if excluded:
+            # For an upsert's DO UPDATE, only return the SET clause (no table name, no WHERE)
+            sql_parts = []
+            sql_parts.append("UPDATE")
+            sql_parts.append("SET " + ", ".join(set_clauses))
+            final_sql = sqlparse.format(
+                " ".join(sql_parts), reindent=True, keyword_case="upper"
+            )
+            return final_sql, tuple(vals)
+        else:
+            sql_parts = []
+            sql_parts.append("UPDATE")
+            sql_parts.append(th.quote(table))
+            sql_parts.append("SET " + ", ".join(set_clauses))
             if where_clauses:
-                sql.append("WHERE " + " AND ".join(where_clauses))
-            else:
-                # Without a WHERE, this updates all rows.
-                # If this is not desired, raise an error.
-                if not excluded:
-                    raise ValueError(
-                        "No WHERE clause could be constructed. Update would affect all rows."
-                    )
-
-        # Final assembled query
-        sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
-        return sql, tuple(vals)
+                sql_parts.append("WHERE " + " AND ".join(where_clauses))
+            final_sql = sqlparse.format(
+                " ".join(sql_parts), reindent=True, keyword_case="upper"
+            )
+            return final_sql, tuple(vals)
 
     @classmethod
     def insert(cls, table, data):
+        """
+        Generate an INSERT statement.
+        """
+
         keys = []
-        vals = []
+        vals_placeholders = []
         args = []
         for key, val in data.items():
             keys.append(TableHelper.quote(key.lower()))
             if isinstance(val, str) and len(val) > 2 and val[:2] == "@@" and val[2:]:
-                vals.append(val[2:])
+                vals_placeholders.append(val[2:])
             else:
-                vals.append("%s")
+                vals_placeholders.append("%s")
                 args.append(val)
 
-        sql = ["INSERT INTO"]
-        sql.append(TableHelper.quote(table))
-        sql.append("(")
-        sql.append(",".join(keys))
-        sql.append(")")
-        sql.append("VALUES")
-        sql.append("(")
-        sql.append(",".join(vals))
-        sql.append(")")
-        sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
+        sql_parts = []
+        sql_parts.append("INSERT INTO")
+        sql_parts.append(TableHelper.quote(table))
+        sql_parts.append("(")
+        sql_parts.append(",".join(keys))
+        sql_parts.append(")")
+        sql_parts.append("VALUES")
+        sql_parts.append("(")
+        sql_parts.append(",".join(vals_placeholders))
+        sql_parts.append(")")
+        sql = sqlparse.format(" ".join(sql_parts), reindent=True, keyword_case="upper")
         return sql, tuple(args)
 
     @classmethod
@@ -397,21 +419,23 @@ class SQL:
             pkeys = tx.table(table).primary_keys()
             if not pkeys:
                 raise ValueError("Primary key required for merge.")
-            # If there are multiple primary keys, we need to use all of them
+            # If there are multiple primary keys, use all of them
             if len(pkeys) > 1:
                 pk = {pk: data[pk] for pk in pkeys}
             else:
                 pk = {pkeys[0]: data[pkeys[0]]}
-            # remove primary key from data
+            # Remove primary keys from data; they will be used in the conflict target
             data = {k: v for k, v in data.items() if k not in pk}
 
+        # Create a merged dictionary for insert (data + primary key columns)
         full_data = {}
         full_data.update(data)
         full_data.update(pk)
 
         sql, vals = cls.insert(table, full_data)
         sql = [sql]
-        vals = list(vals)
+        vals = list(vals)  # Convert to a mutable list
+
         if on_conflict_do_nothing != on_conflict_update:
             sql.append("ON CONFLICT")
             sql.append("(")
@@ -421,15 +445,20 @@ class SQL:
             if on_conflict_do_nothing:
                 sql.append("NOTHING")
             elif on_conflict_update:
-                sql2, vals2 = cls.update(tx, table, data, pk, excluded=True)
-                sql.append(sql2)
-                vals.extend(vals2)
+                # Call update() with excluded=True to produce the SET clause for the upsert.
+                sql_update, vals_update = cls.update(tx, table, data, pk, excluded=True)
+                sql.append(sql_update)
+                # Use list.extend to add the update values to vals.
+                vals.extend(vals_update)
         else:
             raise Exception(
                 "Update on conflict must have one and only one option to complete on conflict."
             )
-        sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
-        return sql, tuple(vals)
+
+        import sqlparse
+
+        final_sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
+        return final_sql, tuple(vals)
 
     @classmethod
     def version(cls):
@@ -513,9 +542,9 @@ class SQL:
     @classmethod
     def create_table(cls, name, columns={}, drop=False):
         if "." in name:
-            fqtn = name
+            fqtn = TableHelper.quote(name)
         else:
-            fqtn = f"public.{name}"
+            fqtn = f"public.{TableHelper.quote(name)}"
         schema, table = fqtn.split(".")
         name = fqtn.replace(".", "_")
         sql = []
@@ -563,7 +592,7 @@ class SQL:
         )
 
         for key, val in columns.items():
-            key = re.sub("<>!=%", "", key.lower())
+            key = re.sub("<>!=%", "", key)
             if key in system_fields:
                 continue
             sql.append(
@@ -797,7 +826,7 @@ class SQL:
         if "." not in table and schema:
             table = f"{schema}.{table}"
         if isinstance(columns, (list, set)):
-            columns = ",".join([TableHelper.quote(c.lower()) for c in columns])
+            columns = ",".join([TableHelper.quote(c) for c in columns])
         else:
             columns = TableHelper.quote(columns)
         sql = ["CREATE"]
@@ -858,7 +887,7 @@ class SQL:
         if "." not in table and schema:
             table = f"{schema}.{table}"
         if isinstance(columns, (list, set)):
-            columns = ",".join([TableHelper.quote(c.lower()) for c in columns])
+            columns = ",".join([TableHelper.quote(c) for c in columns])
         else:
             columns = TableHelper.quote(columns)
         sql = ["DROP"]
@@ -880,7 +909,7 @@ class SQL:
 
     @classmethod
     def massage_data(cls, data):
-        data = {key.lower(): val for key, val in data.items()}
+        data = {key: val for key, val in data.items()}
         primaryKey = set(cls.GetPrimaryKeyColumnNames())
         if not primaryKey:
             if not cls.Exists():
@@ -895,23 +924,43 @@ class SQL:
 
     @classmethod
     def alter_add(cls, table, columns, null_allowed=True):
+        """
+        Modify the table to add new columns. If the `value` is 'now()', treat it as a
+        TIMESTAMP type (optionally with a DEFAULT now() clause).
+        """
         sql = []
-        null = "NOT NULL" if not null_allowed else ""
+        null_clause = "NOT NULL" if not null_allowed else ""
+
         if isinstance(columns, dict):
-            for key, val in columns.items():
-                key = re.sub("<>!=%", "", key.lower())
-                sql.append(
-                    f"ALTER TABLE {TableHelper.quote(table)} ADD {TableHelper.quote(key)} {TYPES.get_type(val)} {null};"
-                )
-        sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
-        return sql, tuple()
+            for col_name, val in columns.items():
+                col_name_clean = re.sub("<>!=%", "", col_name)
+                # If the user wants 'now()' to be recognized as a TIMESTAMP column:
+                if isinstance(val, str) and val.strip().lower() == "@@now()":
+                    # We assume the user wants the type to be TIMESTAMP
+                    # Optionally we can also add `DEFAULT now()` if desired
+                    # so that newly added rows use the current timestamp
+                    col_type = "TIMESTAMP"
+                    sql.append(
+                        f"ALTER TABLE {TableHelper.quote(table)} "
+                        f"ADD {TableHelper.quote(col_name_clean)} {col_type} {null_clause};"
+                    )
+                else:
+                    # Normal code path: rely on your `TYPES.get_type(...)` logic
+                    col_type = TYPES.get_type(val)
+                    sql.append(
+                        f"ALTER TABLE {TableHelper.quote(table)} "
+                        f"ADD {TableHelper.quote(col_name_clean)} {col_type} {null_clause};"
+                    )
+
+        final_sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
+        return final_sql, tuple()
 
     @classmethod
     def alter_drop(cls, table, columns):
         sql = [f"ALTER TABLE {TableHelper.quote(table)} DROP COLUMN"]
         if isinstance(columns, dict):
             for key, val in columns.items():
-                key = re.sub("<>!=%", "", key.lower())
+                key = re.sub("<>!=%", "", key)
                 sql.append(f"{key},")
         if sql[-1][-1] == ",":
             sql[-1] = sql[-1][:-1]
@@ -963,7 +1012,7 @@ class SQL:
 
     @classmethod
     def delete(cls, tx, table, where):
-        sql = [f"DELETE FROM {table}"]
+        sql = [f"DELETE FROM {TableHelper.quote(table)}"]
         vals = []
         if where:
             s, v = TableHelper(tx, table).make_where(where)

{velocity_python-0.0.66 → velocity_python-0.0.68}/src/velocity/db/servers/tablehelper.py

@@ -141,27 +141,58 @@ class TableHelper:
 
     def extract_column_name(self, sql_expression):
         """
-        Extracts the 'bare' column name from an expression, ignoring function calls, operators, etc.
+        Extracts the 'bare' column name from a SQL expression.
+
+        Supports:
+        - Aliases (AS ...)
+        - Window functions (OVER(... ORDER BY ...))
+        - CAST(... AS ...)
+        - CASE WHEN ... THEN ... ELSE ... END
+        - Nested function calls
+        - Grabs column from inside expressions (e.g. PLAID_ERROR from SUM(CASE...))
+
+        Args:
+            sql_expression (str): SQL expression (SELECT column) string.
+
+        Returns:
+            str or None: Extracted column name or None if undetectable.
         """
-        expr = sql_expression.replace('"', "")
+        expr = sql_expression.replace('"', "").strip()
 
-        # Remove any alias part (e.g., "as num_donors").
-        # This regex removes any trailing alias defined using "as".
+        # Remove trailing alias
         expr = re.sub(r"(?i)\s+as\s+\w+$", "", expr).strip()
 
-        expr = self.remove_operator(expr)
-        if not self.are_parentheses_balanced(expr):
-            raise ValueError(f"Unbalanced parentheses in expression: {expr}")
+        # If OVER clause: extract column inside ORDER BY
+        over_match = re.search(r"(?i)OVER\s*\(\s*ORDER\s+BY\s+([^\s,)]+)", expr)
+        if over_match:
+            return over_match.group(1)
+
+        # Remove CAST(... AS ...)
+        while re.search(r"(?i)CAST\s*\(([^()]+?)\s+AS\s+[^\)]+\)", expr):
+            expr = re.sub(r"(?i)CAST\s*\(([^()]+?)\s+AS\s+[^\)]+\)", r"\1", expr)
+
+        # Remove CASE WHEN ... THEN ... ELSE ... END, keep just the WHEN part
+        while re.search(
+            r"(?i)CASE\s+WHEN\s+(.+?)\s+THEN\s+.+?(?:\s+ELSE\s+.+?)?\s+END", expr
+        ):
+            expr = re.sub(
+                r"(?i)CASE\s+WHEN\s+(.+?)\s+THEN\s+.+?(?:\s+ELSE\s+.+?)?\s+END",
+                r"\1",
+                expr,
+            )
 
-        # Remove outer function calls, preserving inside parentheses.
-        while "(" in expr or ")" in expr:
-            expr = re.sub(r"\b\w+\s*\((.*?)\)", r"\1", expr)
+        # Unwrap function calls (SUM(...), MAX(...), etc.)
+        while re.search(r"\b\w+\s*\(([^()]+)\)", expr):
+            expr = re.sub(r"\b\w+\s*\(([^()]+)\)", r"\1", expr)
 
+        # If multiple columns, take the first
         if "," in expr:
             expr = expr.split(",")[0].strip()
 
-        pattern = r"^([a-zA-Z0-9_]+\.\*|\*|[a-zA-Z0-9_>]+(?:\.[a-zA-Z0-9_]+)?)$"
-        match = re.search(pattern, expr)
+        # Extract column name (basic or dotted like table.col or *)
+        match = re.search(
+            r"\b([a-zA-Z_][\w]*\.\*|\*|[a-zA-Z_][\w]*(?:\.[a-zA-Z_][\w]*)?)\b", expr
+        )
         return match.group(1) if match else None
 
     def are_parentheses_balanced(self, expression):
@@ -212,8 +243,8 @@ class TableHelper:
         # Lists / tuples => IN / NOT IN
         if isinstance(val, (list, tuple)) and "><" not in key:
             if "!" in key:
-                return f"{column} NOT IN %s", list(val)
-            return f"{column} IN %s", list(val)
+                return f"{column} != ANY(%s)", list(val)
+            return f"{column} = ANY(%s)", list(val)
 
         # "@@" => pass as literal
         if isinstance(val, str) and val.startswith("@@") and val[2:]:

velocity_python-0.0.68/src/velocity/misc/tools.py

@@ -0,0 +1,39 @@
+import os
+import inspect
+import hashlib
+
+
+def run_once(func, *args, **kwargs):
+    """
+    Executes 'func(*args, **kwargs)' only once across script runs.
+
+    The sentinel file name is automatically generated based on the function's
+    module and name. If the function is a lambda, a stable hash of its bytecode
+    is used in place of a function name.
+    """
+
+    def _generate_sentinel_name(_func):
+        # Use __module__ to get the name of the module where _func is defined.
+        module_name = getattr(_func, "__module__", "unknown_module")
+        # Use __name__ to get the function name; for lambdas, this is "<lambda>"
+        function_name = getattr(_func, "__name__", "unknown_func")
+
+        if function_name == "<lambda>":
+            # For lambdas, generate a stable name from a short hash of the bytecode.
+            code_hash = hashlib.md5(_func.__code__.co_code).hexdigest()
+            function_name = f"lambda_{code_hash[:8]}"
+
+        return f".has_run_once_{module_name}_{function_name}"
+
+    # Derive the sentinel filename from the function’s identity
+    sentinel_file = _generate_sentinel_name(func)
+
+    # Check if the sentinel file exists
+    if os.path.exists(sentinel_file):
+        print(f"Code in '{func.__name__}' has already been run. Skipping.")
+    else:
+        # Execute the function for the first time
+        func(*args, **kwargs)
+        # Create an empty sentinel file to mark as "done"
+        with open(sentinel_file, "w") as f:
+            f.write("")

{velocity_python-0.0.66 → velocity_python-0.0.68}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.66
+Version: 0.0.68
 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.66 → velocity_python-0.0.68}/src/velocity_python.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ src/velocity/misc/format.py
 src/velocity/misc/mail.py
 src/velocity/misc/merge.py
 src/velocity/misc/timer.py
+src/velocity/misc/tools.py
 src/velocity/misc/conv/__init__.py
 src/velocity/misc/conv/iconv.py
 src/velocity/misc/conv/oconv.py

velocity_python-0.0.66/src/velocity/db/servers/postgres/__init__.py

@@ -1,19 +0,0 @@
-import os
-import psycopg2
-from .sql import SQL
-from velocity.db.core import engine
-
-default_config = {
-    "database": os.environ["DBDatabase"],
-    "host": os.environ["DBHost"],
-    "port": os.environ["DBPort"],
-    "user": os.environ["DBUser"],
-    "password": os.environ["DBPassword"],
-}
-
-
-def initialize(config=None, **kwargs):
-    if not config:
-        config = default_config.copy()
-    config.update(kwargs)
-    return engine.Engine(psycopg2, config, SQL)