velocity-python 0.1.45__tar.gz → 0.1.47__tar.gz

{velocity_python-0.1.45/src/velocity_python.egg-info → velocity_python-0.1.47}/PKG-INFO

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

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

{velocity_python-0.1.45 → velocity_python-0.1.47}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.45"
+__version__ = version = "0.1.47"
 
 import importlib as _importlib
 

{velocity_python-0.1.45 → velocity_python-0.1.47}/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.45 → velocity_python-0.1.47}/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.47/src/velocity/aws/ssm_config.py

@@ -0,0 +1,180 @@
+"""
+SSM-backed configuration with environment-variable fallback.
+
+``getenv(key)`` reads from SSM at::
+
+    /{ProjectName}/{stage}/{key}
+
+when SSM loading is enabled. An explicit ``VELOCITY_SSM_ENABLED`` environment
+variable still overrides the behavior, but Lambda runtimes now auto-enable SSM
+when they can resolve both project and stage from the runtime environment.
+
+On an SSM miss or any other SSM error, ``getenv`` falls back to ``os.environ``.
+Results are cached for the process lifetime so SSM is called at most once per
+key per Lambda cold start.
+
+Outside Lambda, or when project/stage cannot be resolved, ``getenv`` remains a
+thin wrapper around ``os.environ.get`` with no SSM call.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+_LAMBDA_PROJECT_SUFFIXES = (
+    'QueueHandler',
+    'Scheduler',
+    'WebHooks',
+    'Public',
+    'Events',
+    'Data',
+)
+
+# Per-process cache: key → value (str) or sentinel _MISS.
+_MISS = object()
+_cache: dict[str, object] = {}
+
+# Lazily evaluated once per process.
+_SSM_ENABLED: bool | None = None
+
+
+def _is_enabled() -> bool:
+    global _SSM_ENABLED
+    if _SSM_ENABLED is None:
+        configured = os.environ.get('VELOCITY_SSM_ENABLED')
+        if configured is not None:
+            _SSM_ENABLED = configured.lower() in ('1', 'true', 'yes')
+        else:
+            _SSM_ENABLED = _is_lambda_runtime() and bool(get_project_name()) and bool(get_stage())
+    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 _lambda_function_name() -> str | None:
+    value = os.environ.get('AWS_LAMBDA_FUNCTION_NAME')
+    if value is None:
+        return None
+    value = value.strip()
+    return value or None
+
+
+def _is_lambda_runtime() -> bool:
+    return _lambda_function_name() is not None or os.environ.get('AWS_EXECUTION_ENV', '').startswith('AWS_Lambda_')
+
+
+def _infer_project_name_from_lambda_name() -> str | None:
+    function_name = _lambda_function_name()
+    if function_name is None:
+        return None
+
+    stage = _first_nonempty_env('AppStage', 'ENV', 'USER_BRANCH', 'AWS_BRANCH')
+    base_name = function_name
+    if stage:
+        suffix = f'-{stage}'
+        if base_name.endswith(suffix):
+            base_name = base_name[:-len(suffix)]
+
+    for suffix in _LAMBDA_PROJECT_SUFFIXES:
+        if base_name.endswith(suffix) and len(base_name) > len(suffix):
+            candidate = base_name[:-len(suffix)].strip()
+            if candidate:
+                return candidate
+
+    return base_name or None
+
+
+def get_project_name(default: Optional[str] = None) -> Optional[str]:
+    return _first_nonempty_env('ProjectName') or _infer_project_name_from_lambda_name() 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}/{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
+
+
+def _fetch(key: str) -> str | None:
+    """Single SSM GetParameter call; returns value or None on any failure."""
+    prefix = _ssm_prefix()
+    if prefix is None:
+        return None
+    param_name = f'{prefix}/{key}'
+    try:
+        import boto3
+        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:
+        logger.debug('SSM miss for %s: %s', param_name, exc)
+        return None
+
+
+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 consulted when it is explicitly enabled via
+    ``VELOCITY_SSM_ENABLED=true`` or when Lambda runtime context provides enough
+    information to resolve both project and stage. Explicitly setting
+    ``VELOCITY_SSM_ENABLED=false`` disables SSM even in Lambda.
+
+    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:
+            value = _fetch(key)
+            _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]
+
+    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:
+    """Clear the SSM cache (useful in tests)."""
+    _cache.clear()
+    global _SSM_ENABLED
+    _SSM_ENABLED = None

{velocity_python-0.1.45 → velocity_python-0.1.47}/src/velocity/db/servers/postgres/__init__.py

@@ -98,51 +98,9 @@ class PostgreSQLInitializer(BaseInitializer):
 
 # Maintain backward compatibility
 def initialize(config=None, schema_locked=False, **kwargs):
-    """Backward compatible initialization function - matches original behavior exactly."""
-    try:
-        import psycopg
-    except ImportError as e:
-        raise ImportError(
-            "PostgreSQL driver not available. Install with: pip install velocity-python[postgres]"
-        ) from e
-
-    from .sql import SQL
-
-    konfig = {
-        "dbname": _getenv("DBDatabase") or os.environ["DBDatabase"],
-        "host": _getenv("DBHost") or os.environ["DBHost"],
-        "port": _getenv("DBPort") or os.environ["DBPort"],
-        "user": _getenv("DBUser") or os.environ["DBUser"],
-        "password": _getenv("DBPassword") or os.environ["DBPassword"],
-    }
-    konfig.update(config or {})
-    konfig.update(kwargs)
-
-    # Apply TCP keepalive defaults (user config takes precedence).
-    for key, default_val in _DEFAULT_KEEPALIVE.items():
-        konfig.setdefault(key, default_val)
-
-    # SSL mode.
-    ssl_mode = _getenv("VELOCITY_SSL_MODE")
-    if ssl_mode:
-        konfig.setdefault("sslmode", ssl_mode)
-
-    # Remap legacy 'database' key to 'dbname' for psycopg v3.
-    if "database" in konfig:
-        konfig["dbname"] = konfig.pop("database")
-
-    # Extract pool kwargs so they don't end up in the psycopg connect() call.
-    pool_kwargs = {}
-    for pool_key in ("pool_min", "pool_max", "pool_enabled", "pool_validate"):
-        if pool_key in konfig:
-            pool_kwargs[pool_key] = konfig.pop(pool_key)
-
-    # Check for environment variable override for schema locking
-    if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ("true", "1", "yes"):
-        schema_locked = True
-
-    return engine.Engine(
-        psycopg, konfig, SQL,
+    """Backward compatible wrapper around the shared PostgreSQL initializer."""
+    return PostgreSQLInitializer.initialize(
+        config=config,
         schema_locked=schema_locked,
-        **pool_kwargs,
+        **kwargs,
     )

{velocity_python-0.1.45 → velocity_python-0.1.47/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.45
+Version: 0.1.47
 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.45 → velocity_python-0.1.47}/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.45 → velocity_python-0.1.47}/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.47/tests/test_ssm_config.py

@@ -0,0 +1,132 @@
+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_get_project_name_infers_from_lambda_function_name(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.delenv("ProjectName", raising=False)
+    monkeypatch.setenv("AWS_LAMBDA_FUNCTION_NAME", "BackOfficeScheduler-demo")
+    monkeypatch.setenv("ENV", "demo")
+
+    assert ssm_config.get_project_name() == "BackOffice"
+
+
+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_auto_enables_ssm_in_lambda_with_inferred_project(monkeypatch):
+    ssm_config.clear_cache()
+    monkeypatch.delenv("VELOCITY_SSM_ENABLED", raising=False)
+    monkeypatch.delenv("ProjectName", raising=False)
+    monkeypatch.setenv("AWS_LAMBDA_FUNCTION_NAME", "BackOfficeScheduler-demo")
+    monkeypatch.setenv("ENV", "demo")
+    monkeypatch.setenv("AWS_REGION", "us-west-2")
+    monkeypatch.setenv("DBDatabase", "env-db")
+
+    class FakeSSM:
+        def get_parameter(self, Name, WithDecryption):
+            assert Name == "/BackOffice/demo/DBDatabase"
+            assert WithDecryption is True
+            return {"Parameter": {"Value": "ssm-db"}}
+
+    with patch("boto3.client", return_value=FakeSSM()) as client_factory:
+        assert ssm_config.getenv("DBDatabase") == "ssm-db"
+
+    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.45/src/velocity/aws/ssm_config.py

@@ -1,94 +0,0 @@
-"""
-SSM-backed configuration with environment-variable fallback.
-
-Opt-in: set ``VELOCITY_SSM_ENABLED=true`` in your Amplify environment variables
-(pushed via ``bootstrap.py secrets``).
-
-When enabled, ``getenv(key)`` reads from SSM at::
-
-    /{ProjectName}/{ENV}/{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
-cold start.
-
-When **not** enabled (the default), ``getenv`` is a thin wrapper around
-``os.environ.get`` with zero extra overhead — preserving full backward
-compatibility for projects that don't use SSM (e.g. caringcent).
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-# Per-process cache: key → value (str) or sentinel _MISS.
-_MISS = object()
-_cache: dict[str, object] = {}
-
-# Lazily evaluated once per process.
-_SSM_ENABLED: bool | None = None
-
-
-def _is_enabled() -> bool:
-    global _SSM_ENABLED
-    if _SSM_ENABLED is None:
-        _SSM_ENABLED = os.environ.get('VELOCITY_SSM_ENABLED', '').lower() in ('1', 'true', 'yes')
-    return _SSM_ENABLED
-
-
-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 None
-
-
-def _fetch(key: str) -> str | None:
-    """Single SSM GetParameter call; returns value or None on any failure."""
-    prefix = _ssm_prefix()
-    if prefix is None:
-        return None
-    param_name = f'{prefix}/{key}'
-    try:
-        import boto3
-        ssm = boto3.client('ssm', region_name=os.environ.get('REGION', 'us-east-1'))
-        resp = ssm.get_parameter(Name=param_name, WithDecryption=True)
-        return resp['Parameter']['Value']
-    except Exception as exc:
-        logger.debug('SSM miss for %s: %s', param_name, exc)
-        return None
-
-
-def getenv(key: str, default: Optional[str] = None) -> 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.
-    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.
-    """
-    if _is_enabled():
-        if key not in _cache:
-            value = _fetch(key)
-            _cache[key] = value if value is not None else _MISS
-        cached = _cache[key]
-        if cached is not _MISS:
-            return cached  # type: ignore[return-value]
-
-    return os.environ.get(key, default)
-
-
-def clear_cache() -> None:
-    """Clear the SSM cache (useful in tests)."""
-    _cache.clear()
-    global _SSM_ENABLED
-    _SSM_ENABLED = None