pulumi-extra 0.1.0__py3-none-any.whl

pulumi_extra/__init__.py

@@ -0,0 +1,28 @@
+from .output import render_template
+from .resource_ import get_resource_cls, resource_has_attribute
+from .stack_reference import get_stack_outputs, get_stack_reference, re_export
+from .transforms import (
+    override_default_provider,
+    override_invoke,
+    override_invoke_defaults,
+    override_invoke_options,
+    override_resource,
+    override_resource_defaults,
+    override_resource_options,
+)
+
+__all__ = (
+    "get_resource_cls",
+    "get_stack_outputs",
+    "get_stack_reference",
+    "override_default_provider",
+    "override_invoke",
+    "override_invoke_defaults",
+    "override_invoke_options",
+    "override_resource",
+    "override_resource_defaults",
+    "override_resource_options",
+    "re_export",
+    "render_template",
+    "resource_has_attribute",
+)

pulumi_extra/contrib/aws/__init__.py

@@ -0,0 +1,8 @@
+from .autotag import is_taggable, register_auto_tagging
+from .common import is_aws_resource
+
+__all__ = (
+    "is_aws_resource",
+    "is_taggable",
+    "register_auto_tagging",
+)

pulumi_extra/contrib/aws/autotag.py

@@ -0,0 +1,77 @@
+# noqa: D100
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pulumi
+import pulumi_aws  # noqa: F401; Required to detect resources otherwise `is_taggable` will always return `False`
+
+from pulumi_extra import resource_has_attribute
+
+from .common import is_aws_resource
+
+_NOT_TAGGABLE_RESOURCES: set[str] = {
+    "aws:autoscaling/group:Group",
+    "aws:devopsguru/resourceCollection:ResourceCollection",
+}
+
+
+def register_auto_tagging(
+    *,
+    exclude: set[str] | None = None,
+    extra: dict[str, str] | None = None,
+) -> None:
+    """Register a Pulumi stack transform that automatically tags resources.
+
+    Args:
+        exclude: Resources to exclude from tagging.
+        extra: Extra tags to add.
+    """
+    tags = {}
+    extra = extra or {}
+    exclude = exclude or set()
+
+    # Pulumi tags
+    org = pulumi.get_organization()
+    project = pulumi.get_project()
+    stack = pulumi.get_stack()
+    tags.update(
+        {
+            "pulumi:Organization": org,
+            "pulumi:Project": project,
+            "pulumi:Stack": stack,
+            "Managed-By": "Pulumi",
+        },
+    )
+    tags.update(extra)
+
+    def transform(
+        args: pulumi.ResourceTransformArgs,
+    ) -> pulumi.ResourceTransformResult | None:
+        if args.type_ not in exclude and is_taggable(args.type_):
+            if TYPE_CHECKING:
+                assert isinstance(args.props, dict)
+            args.props["tags"] = {
+                **tags,
+                **(args.props.get("tags", {})),
+            }
+            return pulumi.ResourceTransformResult(props=args.props, opts=args.opts)
+
+        return None
+
+    pulumi.runtime.register_resource_transform(transform)
+
+
+def is_taggable(resource_type: str) -> bool:
+    """Determine if a given AWS resource type is taggable."""
+    if not is_aws_resource(resource_type):
+        pulumi.log.debug(f"Resource type {resource_type} is not a AWS resource")
+        return False
+
+    if resource_type in _NOT_TAGGABLE_RESOURCES:
+        pulumi.log.info(
+            f"Resource type {resource_type} is set not-taggable explicitly",
+        )
+        return False
+
+    return resource_has_attribute(resource_type, "tags")

pulumi_extra/contrib/aws/common.py

@@ -0,0 +1,4 @@
+# noqa: D100
+def is_aws_resource(resource_type: str) -> bool:
+    """Determine if a given resource type is an AWS resource."""
+    return resource_type.startswith("aws:")

pulumi_extra/contrib/aws/policies/__init__.py

@@ -0,0 +1,4 @@
+from .require_description import require_description
+from .require_tags import require_tags
+
+__all__ = ("require_description", "require_tags")

pulumi_extra/contrib/aws/policies/require_description.py

@@ -0,0 +1,60 @@
+# noqa: D100
+import pulumi_policy as policy
+
+from pulumi_extra import resource_has_attribute
+from pulumi_extra.contrib.aws import is_aws_resource, is_taggable
+
+
+class RequireDescription:
+    """Policy validator to require description (or tag if unsupported) on resources."""
+
+    def __init__(
+        self,
+        *,
+        require_tag_if_description_unsupported: bool = False,
+        description_tag_key: str = "Description",
+    ) -> None:
+        """Initialize the policy validator.
+
+        Args:
+            require_tag_if_description_unsupported: Require a tag if description is unsupported.
+                Because AWS tags support human-friendly descriptions,
+                in most cases, using a tag for description is recommended.
+            description_tag_key: The tag key to use for description.
+
+        """
+        self.require_tag_if_description_unsupported = require_tag_if_description_unsupported
+        self.description_tag_key = description_tag_key
+
+    def __call__(  # noqa: D102
+        self,
+        args: policy.ResourceValidationArgs,
+        report_violation: policy.ReportViolation,
+    ) -> None:
+        if not is_aws_resource(args.resource_type):
+            return
+
+        if resource_has_attribute(args.resource_type, "description") and args.props.get("description") is None:
+            report_violation(
+                f"Resource '{args.urn}' is missing required description",
+                None,
+            )
+
+        if self.require_tag_if_description_unsupported:  # noqa: SIM102
+            if is_taggable(args.resource_type):
+                tags = args.props.get("tags", {})
+                if self.description_tag_key not in tags:
+                    report_violation(
+                        f"Resource '{args.urn}' is missing required tag '{self.description_tag_key}'",
+                        None,
+                    )
+
+
+require_description = policy.ResourceValidationPolicy(
+    name="aws:require-description",
+    description="Require description (or tag if unsupported) on resources",
+    config_schema=policy.PolicyConfigSchema(
+        properties={},
+    ),
+    validate=RequireDescription(),
+)

pulumi_extra/contrib/aws/policies/require_tags.py

@@ -0,0 +1,42 @@
+# noqa: D100
+import pulumi_policy as policy
+
+from pulumi_extra.contrib.aws import is_aws_resource, is_taggable
+
+
+class RequireTags:
+    """Policy validator to require specific tags on resources."""
+
+    def __call__(  # noqa: D102
+        self,
+        args: policy.ResourceValidationArgs,
+        report_violation: policy.ReportViolation,
+    ) -> None:
+        config = args.get_config()
+        required_tags = config["required-tags"]
+        if not required_tags or not is_aws_resource(args.resource_type):
+            return
+
+        if is_taggable(args.resource_type):
+            tags = args.props.get("tags", {})
+            for rt in required_tags:
+                if not tags or rt not in tags:
+                    report_violation(
+                        f"Resource '{args.urn}' is missing required tag '{rt}'",
+                        None,
+                    )
+
+
+require_tags = policy.ResourceValidationPolicy(
+    name="aws:require-tags",
+    description="Require specific tags on resources",
+    config_schema=policy.PolicyConfigSchema(
+        properties={
+            "required-tags": {
+                "type": "array",
+                "items": {"type": "string"},
+            },
+        },
+    ),
+    validate=RequireTags(),
+)

pulumi_extra/contrib/gcp/__init__.py

@@ -0,0 +1,8 @@
+from .autolabel import is_labelable, register_auto_labeling
+from .common import is_gcp_resource
+
+__all__ = (
+    "is_gcp_resource",
+    "is_labelable",
+    "register_auto_labeling",
+)

pulumi_extra/contrib/gcp/autolabel.py

@@ -0,0 +1,75 @@
+# noqa: D100
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pulumi
+import pulumi_gcp  # noqa: F401; Required to detect resources otherwise `is_labelable` will always return `False`
+
+from pulumi_extra import resource_has_attribute
+
+from .common import is_gcp_resource
+
+_NOT_LABELABLE_RESOURCES: set[str] = set()
+
+
+def register_auto_labeling(
+    *,
+    exclude: set[str] | None = None,
+    extra: dict[str, str] | None = None,
+) -> None:
+    """Register a Pulumi stack transform that automatically labels resources.
+
+    Args:
+        exclude: Resources to exclude from labeling.
+        extra: Extra labels to add.
+    """
+    labels = {}
+    extra = extra or {}
+    exclude = exclude or set()
+
+    # Pulumi labels
+    # NOTE: Labels transformed because of strict restrictions GCP enforces
+    org = pulumi.get_organization()
+    project = pulumi.get_project()
+    stack = pulumi.get_stack()
+    labels.update(
+        {
+            "pulumi-organization": org,
+            "pulumi-project": project.replace(".", "-"),
+            "pulumi-stack": stack,
+            "managed-by": "pulumi",
+        },
+    )
+    labels.update(extra)
+
+    def transform(
+        args: pulumi.ResourceTransformArgs,
+    ) -> pulumi.ResourceTransformResult | None:
+        if args.type_ not in exclude and is_labelable(args.type_):
+            if TYPE_CHECKING:
+                assert isinstance(args.props, dict)
+            args.props["labels"] = {
+                **labels,
+                **(args.props.get("labels", {})),
+            }
+            return pulumi.ResourceTransformResult(props=args.props, opts=args.opts)
+
+        return None
+
+    pulumi.runtime.register_resource_transform(transform)
+
+
+def is_labelable(resource_type: str) -> bool:
+    """Determine if a given GCP resource type is labelable."""
+    if not is_gcp_resource(resource_type):
+        pulumi.log.debug(f"Resource type {resource_type} is not a GCP resource")
+        return False
+
+    if resource_type in _NOT_LABELABLE_RESOURCES:
+        pulumi.log.info(
+            f"Resource type {resource_type} is set not-labelable explicitly",
+        )
+        return False
+
+    return resource_has_attribute(resource_type, "labels")

pulumi_extra/contrib/gcp/common.py

@@ -0,0 +1,4 @@
+# noqa: D100
+def is_gcp_resource(resource_type: str) -> bool:
+    """Determine if a given resource type is an AWS resource."""
+    return resource_type.startswith("gcp:")

pulumi_extra/contrib/gcp/policies/__init__.py

@@ -0,0 +1,4 @@
+from .require_description import require_description
+from .require_labels import require_labels
+
+__all__ = ("require_description", "require_labels")

pulumi_extra/contrib/gcp/policies/require_description.py

@@ -0,0 +1,60 @@
+# noqa: D100
+import pulumi_policy as policy
+
+from pulumi_extra import resource_has_attribute
+from pulumi_extra.contrib.gcp import is_gcp_resource, is_labelable
+
+
+class RequireDescription:
+    """Policy validator to require description (or label if unsupported) on resources."""
+
+    def __init__(
+        self,
+        *,
+        require_label_if_description_unsupported: bool = False,
+        description_label_key: str = "description",
+    ) -> None:
+        """Initialize the policy validator.
+
+        Args:
+            require_label_if_description_unsupported: Require a label if description is unsupported.
+                Because GCP labels does not support human-friendly descriptions,
+                in most cases, using a label for description is not recommended.
+            description_label_key: The label key to use for description.
+
+        """
+        self.require_label_if_description_unsupported = require_label_if_description_unsupported
+        self.description_label_key = description_label_key
+
+    def __call__(  # noqa: D102
+        self,
+        args: policy.ResourceValidationArgs,
+        report_violation: policy.ReportViolation,
+    ) -> None:
+        if not is_gcp_resource(args.resource_type):
+            return
+
+        if resource_has_attribute(args.resource_type, "description") and args.props.get("description") is None:
+            report_violation(
+                f"Resource '{args.urn}' is missing required description",
+                None,
+            )
+
+        if self.require_label_if_description_unsupported:  # noqa: SIM102
+            if is_labelable(args.resource_type):
+                labels = args.props.get("labels", {})
+                if self.description_label_key not in labels:
+                    report_violation(
+                        f"Resource '{args.urn}' is missing required label '{self.description_label_key}'",
+                        None,
+                    )
+
+
+require_description = policy.ResourceValidationPolicy(
+    name="gcp:require-description",
+    description="Require description (or label if unsupported) on resources",
+    config_schema=policy.PolicyConfigSchema(
+        properties={},
+    ),
+    validate=RequireDescription(),
+)

pulumi_extra/contrib/gcp/policies/require_labels.py

@@ -0,0 +1,42 @@
+# noqa: D100
+import pulumi_policy as policy
+
+from pulumi_extra.contrib.gcp import is_gcp_resource, is_labelable
+
+
+class RequireLabels:
+    """Policy validator to require specific labels on resources."""
+
+    def __call__(  # noqa: D102
+        self,
+        args: policy.ResourceValidationArgs,
+        report_violation: policy.ReportViolation,
+    ) -> None:
+        config = args.get_config()
+        required_labels = config["required-labels"]
+        if not required_labels or not is_gcp_resource(args.resource_type):
+            return
+
+        if is_labelable(args.resource_type):
+            labels = args.props.get("labels", {})
+            for rl in required_labels:
+                if not labels or rl not in labels:
+                    report_violation(
+                        f"Resource '{args.urn}' is missing required label '{rl}'",
+                        None,
+                    )
+
+
+require_labels = policy.ResourceValidationPolicy(
+    name="gcp:require-labels",
+    description="Require specific labels on resources",
+    config_schema=policy.PolicyConfigSchema(
+        properties={
+            "required-labels": {
+                "type": "array",
+                "items": {"type": "string"},
+            },
+        },
+    ),
+    validate=RequireLabels(),
+)

pulumi_extra/errors.py

@@ -0,0 +1,3 @@
+# noqa: D100
+class UnknownResourceTypeError(Exception):
+    """Raised when an unknown resource type is encountered."""

pulumi_extra/output.py

@@ -0,0 +1,60 @@
+"""Utils for outputs."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, overload
+
+import pulumi
+from jinja2 import StrictUndefined, Template
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from typing import Any
+
+
+@overload
+def render_template(
+    template: Path | str,
+    *,
+    context: Mapping[str, Any],
+) -> str: ...  # pragma: no cover
+
+
+@overload
+def render_template(
+    template: Path | str,
+    *,
+    inputs: Mapping[str, pulumi.Input[Any]],
+) -> pulumi.Output[str]: ...  # pragma: no cover
+
+
+def render_template(
+    template: Path | str,
+    *,
+    context: Mapping[str, Any] | None = None,
+    inputs: Mapping[str, pulumi.Input[Any]] | None = None,
+) -> str | pulumi.Output[str]:
+    """Render a template file with the given context.
+
+    Args:
+        template: The template file or inline template string.
+        context: The context to render the template with. Conflicts with inputs.
+        inputs: The inputs to render the template with. Conflicts with context.
+    """
+    if isinstance(template, Path):
+        template = template.read_text()
+
+    jinja_tpl = Template(template, undefined=StrictUndefined)
+
+    # Render with Python values.
+    if context is not None and inputs is None:
+        return jinja_tpl.render(context)
+
+    # Render with Pulumi inputs.
+    if context is None and inputs is not None:
+        return pulumi.Output.all(inputs).apply(lambda args: jinja_tpl.render(args[0]))
+
+    # Only one of context or inputs must be provided.
+    msg = "Either context or input must be provided."
+    raise ValueError(msg)

pulumi_extra/resource_.py

@@ -0,0 +1,73 @@
+"""Utility functions for working with Pulumi resources.
+
+References:
+- https://github.com/tlinhart/pulumi-aws-tags
+
+"""
+
+from __future__ import annotations
+
+from functools import cache
+from importlib import import_module
+from inspect import signature
+from typing import TYPE_CHECKING
+
+import pulumi
+from pulumi.runtime.rpc import _RESOURCE_MODULES
+
+from .errors import UnknownResourceTypeError
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from typing import Any
+
+
+@cache
+def resource_has_attribute(resource_type: str, attribute: str) -> bool:
+    """Determine if a given GCP resource type is labelable."""
+    cls = get_resource_cls(resource_type)
+    if cls is None:
+        msg = f"Unable to resolve resource type {resource_type!r}"
+        raise UnknownResourceTypeError(msg)
+
+    sig = signature(cls._internal_init)
+    return attribute in sig.parameters
+
+
+@cache
+def get_resource_cls(resource_type: str) -> Any | None:
+    """Get the Pulumi resource class for a given resource type.
+
+    Args:
+        resource_type: Resource type to get the class for.
+
+    Returns:
+        Pulumi resource class if found, otherwise `None`.
+
+    """
+    try:
+        _, resource = next(filter(lambda k: k[0] == resource_type, _get_resources()))
+    except StopIteration:
+        pulumi.log.debug(f"Resource type {resource_type} not found")
+        return None
+
+    module_name, class_name = resource
+    module = import_module(module_name)
+    return getattr(module, class_name)
+
+
+def _get_resources() -> Iterator[tuple[str, tuple[str, str]]]:
+    """Return Pulumi resource registry.
+
+    Returns:
+        Iterator of tuple containing resource type and resource class.
+
+    """
+    # NOTE: This cannot be cached as the underlying registry (`_RESOURCE_MODULES`) gradually populates
+    for modules in _RESOURCE_MODULES.values():
+        for module in modules:
+            mod_info = module.mod_info  # type: ignore[attr-defined]
+            fqn, classes = mod_info["fqn"], mod_info["classes"]
+            for type_, name in classes.items():
+                # e.g. ("gcp:activedirectory/domain:Domain", ("pulumi_gcp.activedirectory", "Domain"))
+                yield (type_, (fqn, name))

pulumi_extra/stack_reference.py

@@ -0,0 +1,119 @@
+"""Utils for stack references."""
+
+from __future__ import annotations
+
+from functools import cache
+from itertools import chain
+from typing import Any, overload
+
+import pulumi
+from braceexpand import braceexpand
+
+
+@cache
+def get_stack_reference(ref: str) -> pulumi.StackReference:
+    """Resolve given stack reference shorthand to fully qualified stack reference.
+
+    The shorthand can be one of the following:
+
+    - `"{stack}"`
+
+        Returns the stack reference for the current project and organization.
+
+    - `"{project}/{stack}"`
+
+        Returns the stack reference for the current organization.
+
+    - `"{organization}/{project}/{stack}"`
+
+        No change is made to the stack reference.
+
+    """
+    fqr = _resolve_stack_ref(ref)
+    return pulumi.StackReference(fqr)
+
+
+def _resolve_stack_ref(ref: str) -> str:
+    components = ref.split("/")
+    num_components = len(components)
+    if num_components == 1:
+        org = pulumi.get_organization()
+        project = pulumi.get_project()
+        fqr = f"{org}/{project}/{ref}"
+    elif num_components == 2:  # noqa: PLR2004
+        org = pulumi.get_organization()
+        fqr = f"{org}/{ref}"
+    elif num_components == 3:  # noqa: PLR2004
+        fqr = ref
+    else:
+        msg = f"Invalid stack reference: {ref!r}"
+        raise ValueError(msg)
+
+    return fqr
+
+
+@overload
+def get_stack_outputs(ref: str) -> pulumi.Output[Any]: ...  # pragma: no cover
+
+
+@overload
+def get_stack_outputs(*refs: str) -> list[pulumi.Output[Any]]: ...  # pragma: no cover
+
+
+def get_stack_outputs(  # type: ignore[misc]
+    *refs: str,
+) -> pulumi.Output[Any] | list[pulumi.Output[Any]]:
+    """Get outputs from a output reference shorthands. Supports brace expansion.
+
+    - Single output reference: (`"<stack_ref>:<output_key>"`).
+    - Multiple outputs using brace expansion: (`"<stack_ref>:{<output_key_1>,<output_key_2>}"`).
+
+    Args:
+        *refs: Output references.
+
+    """
+    outputs = _get_stack_outputs(*refs)
+    output_values = list(outputs.values())
+    if len(output_values) == 1:
+        return output_values[0]
+
+    return output_values
+
+
+def re_export(*refs: str) -> None:
+    """Re-export outputs from a output reference shorthands.
+
+    Args:
+        *refs: Output references.
+
+    """
+    outputs = _get_stack_outputs(*refs)
+    for (_, output_key), output in outputs.items():
+        pulumi.export(output_key, output)
+
+
+def _get_stack_outputs(*refs: str) -> dict[tuple[str, str], pulumi.Output[Any]]:
+    expand_refs = list(chain.from_iterable(map(braceexpand, refs)))
+    pulumi.log.debug(f"Expanded output references ({refs!r}): {expand_refs!r}")
+
+    fqr: list[tuple] = []
+    for ref in expand_refs:
+        stack_ref, output_key = _resolve_output_ref(ref)
+        fqr.append((stack_ref, output_key))
+
+    outputs: dict[tuple[str, str], pulumi.Output[Any]] = {}
+    for stack_ref, output_key in fqr:
+        sr = get_stack_reference(stack_ref)
+        outputs[(stack_ref, output_key)] = sr.require_output(output_key)
+
+    return outputs
+
+
+def _resolve_output_ref(ref: str) -> tuple[str, str]:
+    components = ref.split(":")
+    stack_ref, output_key = components
+    if not stack_ref or not output_key:
+        msg = f"Invalid output reference: {ref!r}"
+        raise ValueError(msg)
+
+    return stack_ref, output_key

pulumi_extra/transforms/__init__.py

@@ -0,0 +1,13 @@
+from .invoke import override_invoke, override_invoke_defaults, override_invoke_options
+from .resource_ import override_resource, override_resource_defaults, override_resource_options
+from .runtime import override_default_provider
+
+__all__ = (
+    "override_default_provider",
+    "override_invoke",
+    "override_invoke_defaults",
+    "override_invoke_options",
+    "override_resource",
+    "override_resource_defaults",
+    "override_resource_options",
+)

pulumi_extra/transforms/invoke.py

@@ -0,0 +1,86 @@
+"""Pulumi invoke transforms.
+
+Invoke transforms should be register at the runtime level because Pulumi doesn't support
+registering invoke transforms per-invoke basis.
+"""
+
+from __future__ import annotations
+
+from fnmatch import fnmatch
+from itertools import chain
+from typing import TYPE_CHECKING, Any, Callable
+
+import pulumi
+from braceexpand import braceexpand
+
+_Args = dict[str, pulumi.Input[Any]]
+
+
+def override_invoke(
+    *invoke_tokens: str,
+    args: _Args | Callable[[_Args], _Args] | None = None,
+    opts: pulumi.InvokeOptions | Callable[[pulumi.InvokeOptions], pulumi.InvokeOptions] | None = None,
+) -> pulumi.InvokeTransform:
+    """Pulumi transform factory for invoke tokens (`get_*`).
+
+    Args:
+        *invoke_tokens: Invoke tokens to match. Supports glob patterns and brace expand.
+        args: Invoke arguments to override, or a callable that returns the new arguments from given `args.args` input.
+        opts: Invoke options to override, or a callable that returns the new options given `args.opts` input.
+
+    """
+    args_ = args
+
+    def transform(args: pulumi.InvokeTransformArgs) -> pulumi.InvokeTransformResult | None:
+        nonlocal args_, opts
+
+        for it in chain.from_iterable(map(braceexpand, invoke_tokens)):
+            if not fnmatch(args.token, it):
+                continue
+
+            # Transform invoke arguments
+            if TYPE_CHECKING:
+                assert isinstance(args.args, dict)
+
+            if callable(args_):  # noqa: SIM108
+                new_args = args_(args.args)
+            else:
+                new_args = args.args | args_ if args_ is not None else args.args
+
+            # Transform invoke options
+            new_opts = opts(args.opts) if callable(opts) else (opts or pulumi.InvokeOptions())
+            new_opts = pulumi.InvokeOptions.merge(args.opts, new_opts)
+
+            return pulumi.InvokeTransformResult(args=new_args, opts=new_opts)
+
+        return None
+
+    return transform
+
+
+def override_invoke_defaults(*invoke_tokens: str, defaults: dict[str, Any]) -> pulumi.InvokeTransform:
+    """Pulumi transform factory that provides default arguments to matching invoke tokens.
+
+    Args:
+        *invoke_tokens: Invoke tokens to match.
+        defaults: Default arguments.
+
+    """
+    return override_invoke(
+        *invoke_tokens,
+        args=lambda args: defaults | args,
+    )
+
+
+def override_invoke_options(*invoke_tokens: str, **options: Any) -> pulumi.InvokeTransform:
+    """Pulumi transform factory that overrides the invoke options for matching invoke tokens.
+
+    Args:
+        *invoke_tokens: Invoke tokens to match.
+        options: Arguments of `pulumi.InvokeOptions`.
+
+    """
+    return override_invoke(
+        *invoke_tokens,
+        opts=pulumi.InvokeOptions(**options),
+    )

pulumi_extra/transforms/resource_.py

@@ -0,0 +1,84 @@
+"""Pulumi resource transforms."""
+
+from __future__ import annotations
+
+from fnmatch import fnmatch
+from itertools import chain
+from typing import TYPE_CHECKING, Any, Callable
+
+import pulumi
+from braceexpand import braceexpand
+
+_Props = dict[str, pulumi.Input[Any]]
+
+
+def override_resource(
+    *resource_types: str,
+    props: _Props | Callable[[_Props], _Props] | None = None,
+    opts: pulumi.ResourceOptions | Callable[[pulumi.ResourceOptions], pulumi.ResourceOptions] | None = None,
+) -> pulumi.ResourceTransform:
+    """Pulumi transform factory for resources.
+
+    Args:
+        *resource_types: Resource types to match. Supports glob patterns and brace expand.
+        props: Resource properties to override, or a callable that returns the new properties from given `args.props` input.
+        opts: Resource options to override, or a callable that returns the new options given `args.opts` input.
+
+    """  # noqa: E501
+
+    def transform(args: pulumi.ResourceTransformArgs) -> pulumi.ResourceTransformResult | None:
+        nonlocal props, opts
+
+        for rt in chain.from_iterable(map(braceexpand, resource_types)):
+            if not fnmatch(args.type_, rt):
+                continue
+
+            # Transform resource properties
+            if TYPE_CHECKING:
+                assert isinstance(args.props, dict)
+
+            if callable(props):
+                new_props = props(args.props)
+            else:
+                new_props = args.props | props if props is not None else args.props
+
+            # Transform resource options
+            new_opts = opts(args.opts) if callable(opts) else (opts or pulumi.ResourceOptions())
+            new_opts = pulumi.ResourceOptions.merge(args.opts, new_opts)
+
+            return pulumi.ResourceTransformResult(props=new_props, opts=new_opts)
+
+        return None
+
+    return transform
+
+
+def override_resource_defaults(
+    *resource_types: str,
+    defaults: dict[str, pulumi.Input[Any]],
+) -> pulumi.ResourceTransform:
+    """Pulumi transform factory that provides default properties to matching resource types.
+
+    Args:
+        *resource_types: Resource type to match.
+        defaults: Default properties.
+
+    """
+    return override_resource(
+        *resource_types,
+        props=lambda props: defaults | props,
+    )
+
+
+def override_resource_options(*resource_types: str, **options: Any) -> pulumi.ResourceTransform:
+    """Pulumi transform factory that overrides the resource options for resources of given types.
+
+    Args:
+        *resource_types: Resource types to match.
+        options: Arguments of `pulumi.ResourceOptions`.
+
+    """
+    return override_resource(
+        *resource_types,
+        opts=pulumi.ResourceOptions(**options),
+    )

pulumi_extra/transforms/runtime.py

@@ -0,0 +1,23 @@
+"""Runtime-level transforms for Pulumi programs."""
+
+from __future__ import annotations
+
+import pulumi
+
+from .invoke import override_invoke_options
+from .resource_ import override_resource_options
+
+
+def override_default_provider(
+    *rt_or_it: str,
+    provider: pulumi.ProviderResource,
+) -> None:
+    """Override the default provider for resources and invokes of given types.
+
+    Args:
+        *rt_or_it: Resource types or invoke tokens to match.
+        provider: Provider to override.
+
+    """
+    pulumi.runtime.register_resource_transform(override_resource_options(*rt_or_it, provider=provider))
+    pulumi.runtime.register_invoke_transform(override_invoke_options(*rt_or_it, provider=provider))

pulumi_extra-0.1.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: pulumi-extra
+Version: 0.1.0
+Summary: Extra Pulumi utils and resources.
+Author-email: Yuchan Lee <lasuillard@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: <4.0,>=3.9
+Requires-Dist: braceexpand<1,>=0.1.7
+Requires-Dist: jinja2<4,>=3
+Requires-Dist: pulumi<4,>=3
+Provides-Extra: aws
+Requires-Dist: pulumi-aws>=6; extra == 'aws'
+Provides-Extra: dev
+Requires-Dist: mypy~=1.11; extra == 'dev'
+Requires-Dist: ruff~=0.6; extra == 'dev'
+Provides-Extra: gcp
+Requires-Dist: pulumi-gcp>=8; extra == 'gcp'
+Provides-Extra: policy
+Requires-Dist: pulumi-policy<2,>=1; extra == 'policy'
+Provides-Extra: test
+Requires-Dist: coverage~=7.3; extra == 'test'
+Requires-Dist: nox~=2024.10.9; extra == 'test'
+Requires-Dist: pulumi-random>=4.18.0; extra == 'test'
+Requires-Dist: pytest-cov<7,>=5; extra == 'test'
+Requires-Dist: pytest-order>=1.3.0; extra == 'test'
+Requires-Dist: pytest-sugar~=1.0; extra == 'test'
+Requires-Dist: pytest~=8.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pulumi-extra
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/lasuillard/pulumi-extra/actions/workflows/ci.yaml/badge.svg)](https://github.com/lasuillard/pulumi-extra/actions/workflows/ci.yaml)
+[![codecov](https://codecov.io/gh/lasuillard/pulumi-extra/graph/badge.svg?token=uuckU93NAu)](https://codecov.io/gh/lasuillard/pulumi-extra)
+![GitHub Release](https://img.shields.io/github/v/release/lasuillard/pulumi-extra)
+
+Extra Pulumi utils and resources.

pulumi_extra-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+pulumi_extra/__init__.py,sha256=GOzVO3J_Xbe_-FDIT6LjFvdSExsTziqm8-efyaXwVJI,776
+pulumi_extra/errors.py,sha256=S6F6CMnj8BrQZqCYZl4mMMWN-VqC7KRNHG-5BldAs_A,119
+pulumi_extra/output.py,sha256=jJBWi98AIWL87y1J5MMUHjXXK-_Q1gspmveVCi9IQl0,1620
+pulumi_extra/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pulumi_extra/resource_.py,sha256=Nexd9h5dEeJKJqb0w_3lH7NmYSmx7Twl9_ta03j8UDI,2194
+pulumi_extra/stack_reference.py,sha256=66S4aIQyx5HpISaHqT_jsNKNNLAggT5Y5Y2B4n4Smc4,3291
+pulumi_extra/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pulumi_extra/contrib/aws/__init__.py,sha256=atpnUqZUL6C8t20LHK3EgKhPGSU8GlcuRPBpxddloAw,178
+pulumi_extra/contrib/aws/autotag.py,sha256=Y5cwrzRGGrgRHELKXJPvxthRgOnrEeHQEhCCXRi5Ebw,2185
+pulumi_extra/contrib/aws/common.py,sha256=93wyc8KNvgJdmj_rRG2zUa3OTFFDCcu_S-wLosggUs0,171
+pulumi_extra/contrib/aws/policies/__init__.py,sha256=UgZuL2S8sHlK7ULm_OZpgnzOodPejgV50AYCs7GqPPM,143
+pulumi_extra/contrib/aws/policies/require_description.py,sha256=uqqTbYZeOeQNy8j4GjcQqD_nzKFfocAO3l1BRUClhQ8,2160
+pulumi_extra/contrib/aws/policies/require_tags.py,sha256=JZXFvgkkxcNzNGcY4qDMJ6eH-pJAQUjbm5EHFULrx5c,1247
+pulumi_extra/contrib/gcp/__init__.py,sha256=mQghe26s_H0ni0m85wi6LCgk7c8F95bR1ixphP90III,184
+pulumi_extra/contrib/gcp/autolabel.py,sha256=LhS3yHku8P8TRhR9cWWnMTTwvU_JXgOL9PQhmtF7N3U,2214
+pulumi_extra/contrib/gcp/common.py,sha256=hsWt6f9y7GHrEMFNZeqXCT7Gp_deNHJrtNMLrQ7fZfo,171
+pulumi_extra/contrib/gcp/policies/__init__.py,sha256=1iXvLVzQCuOtXl1VMPnq33XlWxo2WTIcJsbaJl6qQuI,149
+pulumi_extra/contrib/gcp/policies/require_description.py,sha256=0vfC0ZPFXel1Pp0JIhBon_lteuZCodIoZsIDfbTaOZ8,2217
+pulumi_extra/contrib/gcp/policies/require_labels.py,sha256=fTjjOGH2YcoLJOYxle3dH7vq9lva8hIrJyvpG12qtm0,1281
+pulumi_extra/transforms/__init__.py,sha256=24I3Uta0nTSGPEuO7udHHu1pZdNdcbwnwV0sn1JhCxE,456
+pulumi_extra/transforms/invoke.py,sha256=IcH3TUFEtGjsRCoF_3rtrvrACGqr8FIWqIlTPlMtS0Q,2778
+pulumi_extra/transforms/resource_.py,sha256=K6HtYgs8swmV2FpYT42H-u9ctpHOwR8ls8hehneuHe8,2716
+pulumi_extra/transforms/runtime.py,sha256=VUFwIcq3BVTKq04v9_54F5xSwmhW_yhXaXmYAS9_b_I,704
+pulumi_extra-0.1.0.dist-info/METADATA,sha256=6BKKQnh67D5iUFGDF1IdI0z_uY_cE0muzMvhPRYK8RE,1568
+pulumi_extra-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pulumi_extra-0.1.0.dist-info/licenses/LICENSE,sha256=Q5GkvYijQ2KTQ-QWhv43ilzCno4ZrzrEuATEQZd9rYo,1067
+pulumi_extra-0.1.0.dist-info/RECORD,,

pulumi_extra-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pulumi_extra-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yuchan Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.