velocity-python 0.1.44__tar.gz → 0.1.46__tar.gz

{velocity_python-0.1.44/src/velocity_python.egg-info → velocity_python-0.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.44
+Version: 0.1.46
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.44 → velocity_python-0.1.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.44"
+version = "0.1.46"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.44 → velocity_python-0.1.46}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.44"
+__version__ = version = "0.1.46"
 
 import importlib as _importlib
 

{velocity_python-0.1.44 → velocity_python-0.1.46}/src/velocity/aws/amplify.py

@@ -446,18 +446,10 @@ class AmplifyProject:
             )
 
     def sync(self, branch):
-        print(
-            f"\n🚀 Syncing environment variables for app '{self.app_id}' and environment '{branch}'..."
-        )
-        env_vars = self.get_merged_env_vars(branch)
-
-        print(f"\n🔧 Applying {len(env_vars)} environment variables...")
-        for function_name in self.list_lambda_functions_filtered(branch):
-            print(f"➡️ Updating Lambda function: {function_name}")
-            self.update_lambda_function(function_name, env_vars)
-
-        print(
-            "✅ Environment variables successfully applied to matching Lambda functions.\n"
+        raise RuntimeError(
+            "AmplifyProject.sync() is retired. Lambda environment variables are no "
+            "longer copied from Amplify configuration. Use SSM-backed runtime "
+            "configuration instead."
         )
 
 

{velocity_python-0.1.44 → velocity_python-0.1.46}/src/velocity/aws/amplify_build.py

@@ -450,13 +450,6 @@ def run_backend_deployment(
     queue_handler = None
     queue_producers = []
     pending_logging = []
-
-    env_vars = build_environment_variables(
-        app,
-        branch,
-        queue_name,
-        project_root=project_root,
-    )
     subnet_ids = list(config.subnet_ids) if config.subnet_ids else None
     security_group_ids = (
         list(config.security_group_ids) if config.security_group_ids else None
@@ -491,7 +484,6 @@ def run_backend_deployment(
         )
         app.update_lambda_function(
             function_name=function_name,
-            merge_env_vars=env_vars,
             timeout=timeout_value,
             memory_size=memory_value,
             subnet_ids=subnet_ids,

{velocity_python-0.1.44 → velocity_python-0.1.46}/src/velocity/aws/ssm_config.py

@@ -6,7 +6,7 @@ Opt-in: set ``VELOCITY_SSM_ENABLED=true`` in your Amplify environment variables
 
 When enabled, ``getenv(key)`` reads from SSM at::
 
-    /{ProjectName}/{ENV}/{key}
+    /{ProjectName}/{stage}/{key}
 
 and falls back to ``os.environ`` on a miss or any error.  Results are cached
 for the process lifetime so SSM is called at most once per key per Lambda
@@ -40,12 +40,35 @@ def _is_enabled() -> bool:
     return _SSM_ENABLED
 
 
+def _first_nonempty_env(*keys: str) -> str | None:
+    for key in keys:
+        value = os.environ.get(key)
+        if value is None:
+            continue
+        value = value.strip()
+        if value:
+            return value
+    return None
+
+
+def get_project_name(default: Optional[str] = None) -> Optional[str]:
+    return _first_nonempty_env('ProjectName') or default
+
+
+def get_stage(default: Optional[str] = None) -> Optional[str]:
+    return _first_nonempty_env('AppStage', 'ENV', 'USER_BRANCH', 'AWS_BRANCH') or default
+
+
+def get_region(default: Optional[str] = 'us-east-1') -> Optional[str]:
+    return _first_nonempty_env('AWS_REGION', 'REGION', 'USER_REGION') or default
+
+
 def _ssm_prefix() -> str | None:
-    """Return '/{ProjectName}/{ENV}' or None if either var is missing."""
-    project = os.environ.get('ProjectName')
-    env = os.environ.get('ENV')
-    if project and env:
-        return f'/{project}/{env}'
+    """Return '/{ProjectName}/{stage}' or None if either component is missing."""
+    project = get_project_name()
+    stage = get_stage()
+    if project and stage:
+        return f'/{project}/{stage}'
     return None
 
 
@@ -57,7 +80,7 @@ def _fetch(key: str) -> str | None:
     param_name = f'{prefix}/{key}'
     try:
         import boto3
-        ssm = boto3.client('ssm', region_name=os.environ.get('REGION', 'us-east-1'))
+        ssm = boto3.client('ssm', region_name=get_region('us-east-1'))
         resp = ssm.get_parameter(Name=param_name, WithDecryption=True)
         return resp['Parameter']['Value']
     except Exception as exc:
@@ -65,16 +88,25 @@ def _fetch(key: str) -> str | None:
         return None
 
 
-def getenv(key: str, default: Optional[str] = None) -> Optional[str]:
+def getenv(
+    key: str,
+    default: Optional[str] = None,
+    *,
+    raise_on_missing: bool = False,
+) -> Optional[str]:
     """
     Read a config value, checking SSM before ``os.environ``.
 
     SSM is only consulted when ``VELOCITY_SSM_ENABLED=true`` is set in the
-    Lambda environment *and* both ``ProjectName`` and ``ENV`` are present.
+    Lambda environment *and* both ``ProjectName`` and a resolved stage are present.
     All other cases fall straight through to ``os.environ``.
 
     Results are cached per process so SSM is queried at most once per key
     per Lambda cold start.
+
+    When ``raise_on_missing`` is true, this raises ``KeyError`` if neither
+    SSM nor ``os.environ`` contains a non-empty value for the requested key.
+    In that mode, the provided default is ignored.
     """
     if _is_enabled():
         if key not in _cache:
@@ -82,9 +114,14 @@ def getenv(key: str, default: Optional[str] = None) -> Optional[str]:
             _cache[key] = value if value is not None else _MISS
         cached = _cache[key]
         if cached is not _MISS:
+            if raise_on_missing and cached == "":
+                raise KeyError(f'{key} not found in SSM or environment')
             return cached  # type: ignore[return-value]
 
-    return os.environ.get(key, default)
+    value = os.environ.get(key, default)
+    if raise_on_missing and value in (None, ""):
+        raise KeyError(f'{key} not found in SSM or environment')
+    return value
 
 
 def clear_cache() -> None:

{velocity_python-0.1.44 → velocity_python-0.1.46}/src/velocity/db/core/table.py

@@ -234,6 +234,63 @@ def _normalize_index_expression(expression):
     return normalized.strip().lower()
 
 
+def _split_top_level_boolean_terms(expression):
+    parts = []
+    operators = []
+    start = 0
+    depth = 0
+    position = 0
+    while position < len(expression):
+        char = expression[position]
+        if char == "(":
+            depth += 1
+            position += 1
+            continue
+        if char == ")":
+            depth = max(0, depth - 1)
+            position += 1
+            continue
+        if depth == 0:
+            lowered = expression[position:].lower()
+            for operator in (" and ", " or "):
+                if lowered.startswith(operator):
+                    parts.append(expression[start:position].strip())
+                    operators.append(operator.strip())
+                    position += len(operator)
+                    start = position
+                    break
+            else:
+                position += 1
+            continue
+        position += 1
+
+    if operators:
+        parts.append(expression[start:].strip())
+
+    return parts, operators
+
+
+def _normalize_index_where_clause(expression):
+    normalized = _normalize_index_expression(expression)
+    parts, operators = _split_top_level_boolean_terms(normalized)
+    if not operators:
+        return normalized
+
+    simplified_parts = []
+    for part in parts:
+        stripped = _strip_redundant_outer_parens(part)
+        nested_parts, nested_operators = _split_top_level_boolean_terms(stripped)
+        if nested_operators:
+            simplified_parts.append(part)
+        else:
+            simplified_parts.append(stripped)
+
+    combined = [simplified_parts[0]]
+    for operator, part in zip(operators, simplified_parts[1:]):
+        combined.extend([operator, part])
+    return " ".join(combined).strip()
+
+
 def _parse_index_signature(index_sql):
     normalized_sql = " ".join(str(index_sql or "").split())
     upper_sql = normalized_sql.upper()
@@ -257,7 +314,7 @@ def _parse_index_signature(index_sql):
     where_clause = None
     where_pos = upper_sql.find(" WHERE ", closing_index)
     if where_pos != -1:
-        where_clause = _normalize_index_expression(normalized_sql[where_pos + 7 :])
+        where_clause = _normalize_index_where_clause(normalized_sql[where_pos + 7 :])
 
     return {
         "name": index_name,
@@ -686,16 +743,23 @@ class Table:
         return signatures
 
     def _desired_index_signature(self, spec):
-        sql, _vals = self.create_index(
-            spec["columns"],
-            unique=spec["unique"],
-            direction=spec["direction"],
-            where=spec["where"],
-            lower=spec["lower"],
-            name=spec["name"],
-            sql_only=True,
-        )
-        return _parse_index_signature(sql)
+        columns = []
+        for column_name in spec["columns"]:
+            normalized_column = _normalize_identifier(column_name)
+            if spec.get("lower"):
+                normalized_column = f"lower({normalized_column})"
+            columns.append(normalized_column)
+
+        return {
+            "name": _normalize_identifier(spec.get("name")) if spec.get("name") else None,
+            "unique": bool(spec.get("unique")),
+            "columns": tuple(columns),
+            "where": (
+                _normalize_index_where_clause(spec.get("where"))
+                if spec.get("where")
+                else None
+            ),
+        }
 
     def _existing_foreign_key_signatures(self):
         sql, vals = self.sql.foreign_key_info(table=self.name, column=None)

{velocity_python-0.1.44 → velocity_python-0.1.46/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.44
+Version: 0.1.46
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.44 → velocity_python-0.1.46}/src/velocity_python.egg-info/SOURCES.txt

@@ -183,6 +183,7 @@ tests/test_security_hardening.py
 tests/test_server_cursor.py
 tests/test_spreadsheet_functions.py
 tests/test_sqs_per_record_transactions.py
+tests/test_ssm_config.py
 tests/test_sys_modified_count_postgres_demo.py
 tests/test_table_alter.py
 tests/test_where_clause_validation.py

{velocity_python-0.1.44 → velocity_python-0.1.46}/tests/test_amplify_build.py

@@ -1,3 +1,6 @@
+import pytest
+
+from velocity.aws.amplify import AmplifyProject
 from velocity.aws.amplify_build import (
     BackendDeploymentConfig,
     build_environment_variables,
@@ -144,7 +147,16 @@ def test_run_backend_deployment_refreshes_lambda_layers(monkeypatch, tmp_path):
     assert app.updated_functions[0]["function_name"] == "ClientEvents-demo"
     assert app.updated_functions[0]["timeout"] == 60
     assert app.updated_functions[0]["memory_size"] == 512
+    assert "merge_env_vars" not in app.updated_functions[0]
     assert app.updated_functions[0]["layers"] == [
         "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-support:240",
         "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-accounting:34",
-    ]
+    ]
+
+
+def test_amplify_project_sync_is_retired():
+    app = AmplifyProject.__new__(AmplifyProject)
+    app.app_id = "app-123"
+
+    with pytest.raises(RuntimeError, match=r"AmplifyProject\.sync\(\) is retired"):
+        app.sync("demo")

velocity_python-0.1.46/tests/test_ssm_config.py

@@ -0,0 +1,102 @@
+from unittest.mock import patch
+
+import pytest
+
+from velocity.aws import ssm_config
+
+
+def test_get_stage_prefers_app_stage_then_aliases(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.setenv("AWS_BRANCH", "production")
+    monkeypatch.setenv("USER_BRANCH", "demo")
+    monkeypatch.setenv("ENV", "sandbox")
+    monkeypatch.setenv("AppStage", "stage")
+
+    assert ssm_config.get_stage() == "stage"
+
+
+def test_ssm_prefix_uses_aws_branch_when_env_missing(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.setenv("ProjectName", "Client")
+    monkeypatch.delenv("ENV", raising=False)
+    monkeypatch.delenv("USER_BRANCH", raising=False)
+    monkeypatch.setenv("AWS_BRANCH", "production")
+
+    assert ssm_config._ssm_prefix() == "/Client/production"
+
+
+def test_getenv_falls_back_to_environment_when_disabled(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.delenv("VELOCITY_SSM_ENABLED", raising=False)
+    monkeypatch.setenv("StripeSecretKey", "env-secret")
+
+    assert ssm_config.getenv("StripeSecretKey") == "env-secret"
+
+
+def test_getenv_reads_ssm_with_region_aliases(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.setenv("VELOCITY_SSM_ENABLED", "true")
+    monkeypatch.setenv("ProjectName", "Client")
+    monkeypatch.setenv("AWS_BRANCH", "production")
+    monkeypatch.setenv("AWS_REGION", "us-west-2")
+    monkeypatch.setenv("StripeSecretKey", "env-secret")
+
+    class FakeSSM:
+        def get_parameter(self, Name, WithDecryption):
+            assert Name == "/Client/production/StripeSecretKey"
+            assert WithDecryption is True
+            return {"Parameter": {"Value": "ssm-secret"}}
+
+    with patch("boto3.client", return_value=FakeSSM()) as client_factory:
+        assert ssm_config.getenv("StripeSecretKey") == "ssm-secret"
+
+    client_factory.assert_called_once_with("ssm", region_name="us-west-2")
+
+
+def test_getenv_raises_on_missing_when_disabled(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.delenv("VELOCITY_SSM_ENABLED", raising=False)
+    monkeypatch.delenv("MissingKey", raising=False)
+
+    with pytest.raises(KeyError, match="MissingKey"):
+        ssm_config.getenv("MissingKey", raise_on_missing=True)
+
+
+def test_getenv_raises_on_missing_after_ssm_miss(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.setenv("VELOCITY_SSM_ENABLED", "true")
+    monkeypatch.setenv("ProjectName", "Client")
+    monkeypatch.setenv("AWS_BRANCH", "production")
+    monkeypatch.delenv("MissingKey", raising=False)
+
+    class FakeSSM:
+        def get_parameter(self, Name, WithDecryption):
+            raise Exception("missing")
+
+    with patch("boto3.client", return_value=FakeSSM()):
+        with pytest.raises(KeyError, match="MissingKey"):
+            ssm_config.getenv("MissingKey", raise_on_missing=True)
+
+
+def test_getenv_raises_on_empty_environment_value(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.delenv("VELOCITY_SSM_ENABLED", raising=False)
+    monkeypatch.setenv("MissingKey", "")
+
+    with pytest.raises(KeyError, match="MissingKey"):
+        ssm_config.getenv("MissingKey", raise_on_missing=True)
+
+
+def test_getenv_raises_on_empty_ssm_value(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.setenv("VELOCITY_SSM_ENABLED", "true")
+    monkeypatch.setenv("ProjectName", "Client")
+    monkeypatch.setenv("AWS_BRANCH", "production")
+
+    class FakeSSM:
+        def get_parameter(self, Name, WithDecryption):
+            return {"Parameter": {"Value": ""}}
+
+    with patch("boto3.client", return_value=FakeSSM()):
+        with pytest.raises(KeyError, match="MissingKey"):
+            ssm_config.getenv("MissingKey", raise_on_missing=True)

{velocity_python-0.1.44 → velocity_python-0.1.46}/tests/test_table_alter.py

@@ -558,6 +558,54 @@ class TableAlterTests(unittest.TestCase):
             _parse_index_signature(desired),
         )
 
+    def test_parse_index_signature_ignores_redundant_boolean_term_parentheses(self):
+        existing = (
+            "CREATE INDEX idx_pending_transactions_scheduled_capture_at "
+            "ON public.pending_transactions USING btree (scheduled_capture_at) "
+            "WHERE ((status = 'authorized'::text) AND (captured_at IS NULL) AND "
+            "(canceled_at IS NULL))"
+        )
+        desired = (
+            "CREATE INDEX idx_pending_transactions_scheduled_capture_at "
+            "ON pending_transactions (scheduled_capture_at) "
+            "WHERE status = 'authorized' AND captured_at IS NULL AND canceled_at IS NULL"
+        )
+
+        self.assertEqual(
+            _parse_index_signature(existing),
+            _parse_index_signature(desired),
+        )
+
+    def test_desired_index_signature_allows_system_columns_not_in_declared_spec(self):
+        table = FakeTable(
+            PostgresSQL,
+            {
+                "product_sys_id": {"type": "BIGINT", "nullable": False},
+            },
+        )
+
+        signature = Table._desired_index_signature(
+            table,
+            {
+                "name": "idx_inventory_ledger_product_sys_id_sys_id",
+                "columns": ["product_sys_id", "sys_id"],
+                "unique": False,
+                "direction": None,
+                "where": None,
+                "lower": None,
+            },
+        )
+
+        self.assertEqual(
+            signature,
+            {
+                "name": "idx_inventory_ledger_product_sys_id_sys_id",
+                "unique": False,
+                "columns": ("product_sys_id", "sys_id"),
+                "where": None,
+            },
+        )
+
 
 if __name__ == "__main__":
     unittest.main()