velocity-python 0.1.85__tar.gz → 0.1.87__tar.gz

{velocity_python-0.1.85/src/velocity_python.egg-info → velocity_python-0.1.87}/PKG-INFO

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

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

{velocity_python-0.1.85 → velocity_python-0.1.87}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.85"
+__version__ = version = "0.1.87"
 
 import importlib as _importlib
 

{velocity_python-0.1.85 → velocity_python-0.1.87}/src/velocity/aws/__init__.py

@@ -23,12 +23,18 @@ class AWS(object):
 # Lazy-load heavy modules (boto3-dependent) on first access
 _LAZY_ATTRS = {
     "AmplifyProject": "velocity.aws.amplify",
+    # Legacy deployment API (shim over velocity.aws.deploy; legacy-union
+    # policy mode). New projects: import from velocity.aws.deploy directly.
     "BackendDeploymentConfig": "velocity.aws.amplify_build",
-    "build_environment_variables": "velocity.aws.amplify_build",
     "get_amplify_app_id_and_branch": "velocity.aws.amplify_build",
     "initialize_build_environment": "velocity.aws.amplify_build",
     "run_backend_deployment": "velocity.aws.amplify_build",
     "update_lambda_layers_to_latest": "velocity.aws.amplify_build",
+    # Platform-neutral deployment API
+    "AmplifyTarget": "velocity.aws.deploy",
+    "DeploymentConfig": "velocity.aws.deploy",
+    "PlainTarget": "velocity.aws.deploy",
+    "run_deployment": "velocity.aws.deploy",
     # S3 utilities
     "generate_presigned_get": "velocity.aws.s3",
     "generate_presigned_put": "velocity.aws.s3",
@@ -71,12 +77,15 @@ def __getattr__(name: str):
 
 __all__ = [
     "AmplifyProject",
+    "AmplifyTarget",
     "AWS",
     "BackendDeploymentConfig",
-    "build_environment_variables",
+    "DeploymentConfig",
+    "PlainTarget",
     "get_amplify_app_id_and_branch",
     "initialize_build_environment",
     "run_backend_deployment",
+    "run_deployment",
     "update_lambda_layers_to_latest",
     # S3 utilities
     "generate_presigned_get",

velocity_python-0.1.87/src/velocity/aws/amplify.py

@@ -0,0 +1,234 @@
+import boto3
+import time
+from collections.abc import Mapping, Sequence
+
+
+class AmplifyProject:
+    def __init__(self, app_id: str):
+        self.app_id = app_id
+        self.amplify_client = boto3.client("amplify")
+        self.lambda_client = boto3.client("lambda")
+        self.sqs_client = boto3.client("sqs")
+        self.sqs_resource = boto3.resource("sqs")
+
+        # Verify app exists
+        try:
+            response = self.amplify_client.get_app(appId=self.app_id)
+            self.app_name = response["app"]["name"]
+        except self.amplify_client.exceptions.NotFoundException:
+            raise ValueError(f"Amplify app with ID '{self.app_id}' does not exist.")
+
+    def get_app_name(self):
+        return self.app_name
+
+    def get_region(self):
+        return self.amplify_client.meta.region_name
+
+    def get_account_id(self):
+        sts_client = boto3.client("sts")
+        return sts_client.get_caller_identity()["Account"]
+
+    def list_backend_branches(self):
+        branches = []
+        paginator = self.amplify_client.get_paginator("list_branches")
+        for page in paginator.paginate(appId=self.app_id):
+            for branch in page.get("branches", []):
+                branches.append(branch["branchName"])
+        return branches
+
+    def filtered_env_vars(self, raw_env_vars):
+        return {k: v for k, v in raw_env_vars.items() if not k.startswith("_")}
+
+    def get_merged_env_vars(self, branch):
+        all_vars = {}
+
+        # Global env vars
+        app_response = self.amplify_client.get_app(appId=self.app_id)
+        global_vars = self.filtered_env_vars(
+            app_response["app"].get("environmentVariables", {})
+        )
+        # print("📦 Global env vars (All branches):")
+        # for k, v in global_vars.items():
+        #     print(f"  {k}: {v}")
+        all_vars.update(global_vars)
+
+        # Branch-specific vars
+        try:
+            branch_response = self.amplify_client.get_branch(
+                appId=self.app_id, branchName=branch
+            )
+            branch_vars = self.filtered_env_vars(
+                branch_response["branch"].get("environmentVariables", {})
+            )
+            # print(f"🌿 Branch-specific env vars for '{branch}':")
+            # for k, v in branch_vars.items():
+            #     print(f"  {k}: {v}")
+            all_vars.update(branch_vars)
+        except self.amplify_client.exceptions.BadRequestException:
+            print(f"⚠️ Branch '{branch}' not found. Skipping branch-level overrides.")
+
+        return all_vars
+
+    def list_lambda_functions_filtered(self, env_name):
+        """
+        List Lambda functions that belong to this Amplify app and environment.
+        Filters by user:Application tag, checking both exact app name and sanitized version.
+        """
+        from velocity.aws.deploy.operations import list_functions_by_tag
+
+        return list_functions_by_tag(
+            self.lambda_client, app_name=self.app_name, stage=env_name
+        )
+
+    def update_lambda_function(
+        self,
+        function_name,
+        **kwargs,
+    ):
+        from velocity.aws.deploy.operations import update_lambda_function_config
+
+        return update_lambda_function_config(
+            self.lambda_client, function_name, **kwargs
+        )
+
+    def set_environment_variable(self, key: str, value: str, branch: str = None):
+        if branch:
+            response = self.amplify_client.get_branch(
+                appId=self.app_id, branchName=branch
+            )
+            env_vars = response["branch"].get("environmentVariables", {})
+            env_vars[key] = value
+            self.amplify_client.update_branch(
+                appId=self.app_id, branchName=branch, environmentVariables=env_vars
+            )
+        else:
+            response = self.amplify_client.get_app(appId=self.app_id)
+            env_vars = response["app"].get("environmentVariables", {})
+            env_vars[key] = value
+            self.amplify_client.update_app(
+                appId=self.app_id, environmentVariables=env_vars
+            )
+
+    def update_custom_redirect_rules(self):
+        # Extensions served as real files; every other path is rewritten to the
+        # SPA. Anything NOT listed here (including static .html pages in
+        # public/) is invisible on the deployed site.
+        srv_list = [
+            "css",
+            "gif",
+            "html",
+            "ico",
+            "jpeg",
+            "jpg",
+            "js",
+            "json",
+            "map",
+            "otf",
+            "png",
+            "svg",
+            "ttf",
+            "txt",
+            "webp",
+            "woff",
+            "xml",
+            "pdf",
+        ]
+        self.amplify_client.update_app(
+            appId=self.app_id,
+            customRules=[
+                {"source": "/<*>", "target": "/index.html", "status": "404-200"},
+                {
+                    "source": f'</^[^.]+$|\\.(?!({"|".join(srv_list)})$)([^.]+$)/>',
+                    "target": "/",
+                    "status": "200",
+                },
+            ],
+        )
+
+    def get_sqs_policy_template(
+        self,
+        queue_name: str,
+        queue_producers: Sequence[Mapping[str, str]],
+        queue_handler: Mapping[str, str],
+    ) -> str:
+        from velocity.aws.deploy.operations import build_sqs_queue_policy
+
+        return build_sqs_queue_policy(
+            self.get_account_id(),
+            self.get_region(),
+            queue_name,
+            queue_producers,
+            queue_handler,
+        )
+
+    def get_lambda_vpc_policy_template(self):
+        from velocity.aws.deploy.policies import baseline_lambda_policy_document
+
+        return baseline_lambda_policy_document(self.get_account_id())
+
+    def setup_sqs_queue_and_permissions(
+        self,
+        branch: str,
+        queue_name: str,
+        queue_producers: Sequence[Mapping[str, str]],
+        queue_handler: Mapping[str, str],
+        use_reserved_concurrency: bool = True,
+    ) -> None:
+        from velocity.aws.deploy.operations import setup_sqs_queue_and_permissions
+
+        setup_sqs_queue_and_permissions(
+            account_id=self.get_account_id(),
+            region=self.get_region(),
+            stage=branch,
+            queue_name=queue_name,
+            queue_producers=queue_producers,
+            queue_handler=queue_handler,
+            use_reserved_concurrency=use_reserved_concurrency,
+            sqs_client=self.sqs_client,
+            sqs_resource=self.sqs_resource,
+            lambda_client=self.lambda_client,
+        )
+
+    def check_policies(self, function):
+        # Attach a role policy
+        iam_client = boto3.client("iam")
+        response = iam_client.list_attached_role_policies(
+            RoleName=function["Role"].split("/")[1]
+        )
+        has_policy_attached = False
+        for policy in response["AttachedPolicies"]:
+            if policy["PolicyName"] == "lambda-vpc-execution":
+                has_policy_attached = True
+        if not has_policy_attached:
+            account_id = self.get_account_id()
+            iam_client.attach_role_policy(
+                PolicyArn=f"arn:aws:iam::{account_id}:policy/lambda-vpc-execution",
+                RoleName=function["Role"].split("/")[1],
+            )
+            time.sleep(15)
+        has_policy_attached = False
+        for policy in response["AttachedPolicies"]:
+            if policy["PolicyName"] == "AmazonSQSFullAccess":
+                has_policy_attached = True
+        if not has_policy_attached:
+            iam_client.attach_role_policy(
+                PolicyArn="arn:aws:iam::aws:policy/AmazonSQSFullAccess",
+                RoleName=function["Role"].split("/")[1],
+            )
+
+    def sync(self, branch):
+        raise RuntimeError(
+            "AmplifyProject.sync() is retired. Lambda environment variables are no "
+            "longer copied from Amplify configuration. Use SSM-backed runtime "
+            "configuration instead."
+        )
+
+
+def main():
+    app_id = "d3c209q3ri53mk"
+    app = AmplifyProject(app_id)
+    print(app.list_backend_branches())
+
+
+if __name__ == "__main__":
+    main()

velocity_python-0.1.87/src/velocity/aws/amplify_build.py

@@ -0,0 +1,160 @@
+"""Backwards-compatibility shim over velocity.aws.deploy.
+
+The deployment engine moved to the platform-neutral velocity.aws.deploy
+package (config / targets / policies / operations / reconcile). This module
+keeps every name and signature the existing project build.py files import,
+with pre-refactor behavior:
+
+- run_backend_deployment() runs in "legacy-union" policy mode (config extras
+  unioned into the shared lambda-vpc-execution policy). Projects migrated to
+  velocity.aws.deploy.run_deployment() get per-app reconciled policies.
+
+New projects should import from velocity.aws.deploy directly.
+"""
+
+import time
+from pathlib import Path
+from typing import Optional, Sequence, Union
+
+import boto3
+
+from velocity.aws.amplify import AmplifyProject
+from velocity.aws.deploy.config import BackendDeploymentConfig, DeploymentConfig
+from velocity.aws.deploy.policies import (
+    IAM_MANAGED_POLICY_MAX_CHARS,
+    ManagedPolicySizeError,
+    _canonical_statement,
+    _ensure_policy_document_size,
+    _merge_policy_statements,
+    _normalize_policy_document,
+    _policy_document_char_count,
+    _serialize_policy_document,
+    attach_role_policies,
+    baseline_lambda_policy_document,
+    sync_managed_policy_document,
+)
+from velocity.aws.deploy.operations import (
+    THROTTLE_ERROR_CODES,
+    ensure_cloudwatch_log_group,
+    resolve_latest_layer_arns,
+    retryable_call,
+)
+from velocity.aws.deploy.operations import (
+    set_cloudwatch_logging as _set_cloudwatch_logging_op,
+)
+from velocity.aws.deploy.reconcile import AWS_SQS_FULL_ACCESS_ARN, run_deployment
+from velocity.aws.deploy.reconcile import (
+    update_lambda_layers_to_latest as _update_layers_new,
+)
+from velocity.aws.deploy.targets import (
+    ANSI_ESCAPE_RE,
+    get_amplify_app_id_and_branch,
+    initialize_build_environment,
+)
+
+# Legacy private alias kept for any direct importers.
+_sync_managed_policy_document = sync_managed_policy_document
+
+
+class _AmplifyProjectTarget:
+    """Adapts a legacy AmplifyProject (+ branch) to the DeployTarget shape."""
+
+    def __init__(self, app: AmplifyProject, branch: str):
+        self._app = app
+        self.app_name = app.app_name
+        self.stage = branch
+
+    def account_id(self) -> str:
+        return self._app.get_account_id()
+
+    def region(self) -> str:
+        return self._app.get_region()
+
+    def list_functions(self):
+        return self._app.list_lambda_functions_filtered(self.stage)
+
+
+def ensure_lambda_policies_and_attach(
+    app: AmplifyProject,
+    function,
+    config: Optional[DeploymentConfig] = None,
+    iam_client=None,
+) -> None:
+    """Legacy per-function policy ensure: union document into the shared
+    lambda-vpc-execution policy, then attach it + AmazonSQSFullAccess."""
+    if iam_client is None:
+        iam_client = boto3.client("iam")
+
+    account_id = app.get_account_id()
+    policy_arn = f"arn:aws:iam::{account_id}:policy/lambda-vpc-execution"
+    policy_document = baseline_lambda_policy_document(account_id)
+    if config is not None:
+        policy_document = config.build_lambda_policy_document(policy_document)
+
+    try:
+        retryable_call(iam_client.get_policy, PolicyArn=policy_arn)
+    except iam_client.exceptions.NoSuchEntityException:
+        _ensure_policy_document_size("lambda-vpc-execution", policy_document)
+        print("Creating policy lambda-vpc-execution")
+        retryable_call(
+            iam_client.create_policy,
+            PolicyName="lambda-vpc-execution",
+            PolicyDocument=_serialize_policy_document(policy_document),
+        )
+        time.sleep(10)
+    else:
+        sync_managed_policy_document(iam_client, policy_arn, policy_document)
+
+    role_name = function["Role"].split("/")[-1]
+    attach_role_policies(iam_client, role_name, [policy_arn, AWS_SQS_FULL_ACCESS_ARN])
+
+
+def set_cloudwatch_logging(
+    app: AmplifyProject,
+    function,
+    branch: str,
+    lambda_client=None,
+    logs_client=None,
+) -> bool:
+    return _set_cloudwatch_logging_op(
+        account_id=app.get_account_id(),
+        region=app.get_region(),
+        function=function,
+        stage=branch,
+        lambda_client=lambda_client,
+        logs_client=logs_client,
+    )
+
+
+def run_backend_deployment(
+    app_id: str,
+    branch: str,
+    config: DeploymentConfig,
+    project_root: Union[str, Path] = ".",
+    app: Optional[AmplifyProject] = None,
+    lambda_client=None,
+    logs_client=None,
+) -> None:
+    if app is None:
+        app = AmplifyProject(app_id)
+    target = _AmplifyProjectTarget(app, branch)
+    run_deployment(
+        target,
+        config,
+        policy_mode="legacy-union",
+        lambda_client=lambda_client,
+        logs_client=logs_client,
+    )
+
+
+def update_lambda_layers_to_latest(
+    app_id: str,
+    branch: str,
+    function_names: Optional[Sequence[str]] = None,
+    app: Optional[AmplifyProject] = None,
+    lambda_client=None,
+) -> None:
+    if app is None:
+        app = AmplifyProject(app_id)
+    target = _AmplifyProjectTarget(app, branch)
+    _update_layers_new(target, function_names=function_names, lambda_client=lambda_client)

velocity_python-0.1.87/src/velocity/aws/deploy/__init__.py

@@ -0,0 +1,75 @@
+"""velocity.aws.deploy — platform-neutral backend deployment.
+
+Public API:
+
+    from velocity.aws.deploy import (
+        DeploymentConfig, AmplifyTarget, PlainTarget,
+        run_deployment, update_lambda_layers_to_latest,
+        initialize_build_environment, get_amplify_app_id_and_branch,
+    )
+
+    target = AmplifyTarget(PROJECT_ROOT)          # existing Amplify apps
+    target = PlainTarget("MyApp", stage="demo")   # no Amplify anywhere
+    run_deployment(target, config)
+
+See docs/deploy.md in the velocity-python repo.
+"""
+
+from velocity.aws.deploy.config import BackendDeploymentConfig, DeploymentConfig
+from velocity.aws.deploy.policies import (
+    IAM_MANAGED_POLICY_MAX_CHARS,
+    ManagedPolicySizeError,
+    app_policy_name,
+    baseline_lambda_policy_document,
+    ensure_app_policy,
+    sync_managed_policy_document,
+)
+from velocity.aws.deploy.operations import (
+    ensure_api_cors_header,
+    ensure_cloudwatch_log_group,
+    ensure_dlq,
+    ensure_identity_pool_developer_provider,
+    list_functions_by_tag,
+    resolve_latest_layer_arns,
+    retryable_call,
+    set_cloudwatch_logging,
+    setup_sqs_queue_and_permissions,
+    update_lambda_function_config,
+)
+from velocity.aws.deploy.targets import (
+    AmplifyTarget,
+    PlainTarget,
+    get_amplify_app_id_and_branch,
+    initialize_build_environment,
+)
+from velocity.aws.deploy.reconcile import (
+    run_deployment,
+    update_lambda_layers_to_latest,
+)
+
+__all__ = [
+    "AmplifyTarget",
+    "BackendDeploymentConfig",
+    "DeploymentConfig",
+    "IAM_MANAGED_POLICY_MAX_CHARS",
+    "ManagedPolicySizeError",
+    "PlainTarget",
+    "app_policy_name",
+    "baseline_lambda_policy_document",
+    "ensure_api_cors_header",
+    "ensure_app_policy",
+    "ensure_cloudwatch_log_group",
+    "ensure_dlq",
+    "ensure_identity_pool_developer_provider",
+    "get_amplify_app_id_and_branch",
+    "initialize_build_environment",
+    "list_functions_by_tag",
+    "resolve_latest_layer_arns",
+    "retryable_call",
+    "run_deployment",
+    "set_cloudwatch_logging",
+    "setup_sqs_queue_and_permissions",
+    "sync_managed_policy_document",
+    "update_lambda_function_config",
+    "update_lambda_layers_to_latest",
+]

velocity_python-0.1.87/src/velocity/aws/deploy/config.py

@@ -0,0 +1,65 @@
+"""Declarative deployment configuration for velocity.aws.deploy.
+
+DeploymentConfig describes everything a project's backend deployment needs:
+queue naming, VPC placement, per-function timeout/memory overrides, and the
+project's IAM policy statements. It is platform-neutral — nothing here assumes
+Amplify.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Mapping, Optional, Sequence, Tuple
+
+
+@dataclass(frozen=True)
+class DeploymentConfig:
+    queue_name_template: str
+    subnet_ids: Tuple[str, ...] = field(default_factory=tuple)
+    security_group_ids: Tuple[str, ...] = field(default_factory=tuple)
+    short_timeout_seconds: int = 60
+    default_timeout_seconds: int = 900
+    short_timeout_tokens: Tuple[str, ...] = (
+        "Events",
+        "Data",
+        "Public",
+        "WebHooks",
+    )
+    memory_size_by_token: Mapping[str, int] = field(default_factory=dict)
+    extra_lambda_policy_statements: Tuple[Mapping[str, Any], ...] = field(
+        default_factory=tuple
+    )
+    use_reserved_concurrency: bool = True
+
+    def resolve_queue_name(self, stage: str) -> str:
+        return self.queue_name_template.format(branch=stage.lower(), raw_branch=stage)
+
+    def resolve_timeout(self, function_name: str) -> int:
+        if any(token in function_name for token in self.short_timeout_tokens):
+            return self.short_timeout_seconds
+        return self.default_timeout_seconds
+
+    def resolve_memory_size(self, function_name: str) -> Optional[int]:
+        for token, memory_size in self.memory_size_by_token.items():
+            if token in function_name:
+                return memory_size
+        return None
+
+    def build_lambda_policy_document(
+        self, base_policy_document: Mapping[str, Any]
+    ) -> Dict[str, Any]:
+        """Legacy helper: base document + this config's extra statements.
+
+        Used only by the legacy shared-union policy mode (velocity.aws
+        amplify_build shim). The per-app policy mode reads
+        extra_lambda_policy_statements directly.
+        """
+        policy_document = dict(base_policy_document)
+        statements = list(policy_document.get("Statement", []))
+        statements.extend(
+            dict(statement) for statement in self.extra_lambda_policy_statements
+        )
+        policy_document["Statement"] = statements
+        return policy_document
+
+
+# Backwards-compatible name used by existing build.py files.
+BackendDeploymentConfig = DeploymentConfig