aws-cdk-lib 2.136.1__tar.gz → 2.137.0__tar.gz

{aws-cdk-lib-2.136.1/src/aws_cdk_lib.egg-info → aws-cdk-lib-2.137.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-cdk-lib
-Version: 2.136.1
+Version: 2.137.0
 Summary: Version 2 of the AWS Cloud Development Kit library
 Home-page: https://github.com/aws/aws-cdk
 Author: Amazon Web Services

{aws-cdk-lib-2.136.1 → aws-cdk-lib-2.137.0}/setup.py

@@ -5,7 +5,7 @@ kwargs = json.loads(
     """
 {
     "name": "aws-cdk-lib",
-    "version": "2.136.1",
+    "version": "2.137.0",
     "description": "Version 2 of the AWS Cloud Development Kit library",
     "license": "Apache-2.0",
     "url": "https://github.com/aws/aws-cdk",
@@ -298,7 +298,7 @@ kwargs = json.loads(
     ],
     "package_data": {
         "aws_cdk._jsii": [
-            "aws-cdk-lib@2.136.1.jsii.tgz"
+            "aws-cdk-lib@2.137.0.jsii.tgz"
         ],
         "aws_cdk": [
             "py.typed"

{aws-cdk-lib-2.136.1 → aws-cdk-lib-2.137.0}/src/aws_cdk/_jsii/__init__.py

@@ -19,7 +19,7 @@ import aws_cdk.asset_node_proxy_agent_v6._jsii
 import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "aws-cdk-lib", "2.136.1", __name__[0:-6], "aws-cdk-lib@2.136.1.jsii.tgz"
+    "aws-cdk-lib", "2.137.0", __name__[0:-6], "aws-cdk-lib@2.137.0.jsii.tgz"
 )
 
 __all__ = [

{aws-cdk-lib-2.136.1 → aws-cdk-lib-2.137.0}/src/aws_cdk/assertions/__init__.py

@@ -582,6 +582,60 @@ For example, the following assertion works as well:
 Annotations.from_stack(stack).has_error("/Default/Foo",
     Match.string_like_regexp(".*Foo::Bar.*"))
 ```
+
+## Asserting Stack tags
+
+Tags applied to a `Stack` are not part of the rendered template: instead, they
+are included as properties in the Cloud Assembly Manifest. To test that stacks
+are tagged as expected, simple assertions can be written.
+
+Given the following setup:
+
+```python
+from aws_cdk import App, Stack
+from aws_cdk.assertions import Tags
+
+app = App()
+stack = Stack(app, "MyStack",
+    tags={
+        "tag-name": "tag-value"
+    }
+)
+```
+
+It is possible to test against these values:
+
+```python
+tags = Tags.from_stack(stack)
+
+# using a default 'objectLike' Matcher
+tags.has_values({
+    "tag-name": "tag-value"
+})
+
+# ... with Matchers embedded
+tags.has_values({
+    "tag-name": Match.string_like_regexp("value")
+})
+
+# or another object Matcher at the top level
+tags.has_values(Match.object_equals({
+    "tag-name": Match.any_value()
+}))
+```
+
+When tags are not defined on the stack, it is represented as an empty object
+rather than `undefined`. To make this more obvious, there is a `hasNone()`
+method that can be used in place of `Match.exactly({})`. If `Match.absent()` is
+passed, an error will result.
+
+```python
+# no tags present
+Tags.from_stack(stack).has_none()
+
+# don't use absent() at the top level, it won't work
+expect(() => { Tags.fromStack(stack).hasValues(Match.absent()); }).to_throw(/will never match/i)
+```
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
@@ -1241,7 +1295,9 @@ class Matcher(
         #     "MyBar": {
         #       "Type": "Foo::Bar",
         #       "Properties": {
-        #         "Fred": ["Flob", "Cat"]
+        #         "Fred": {
+        #           "Wobble": ["Flob", "Flib"],
+        #         }
         #       }
         #     }
         #   }
@@ -1249,13 +1305,17 @@ class Matcher(
         
         # The following will NOT throw an assertion error
         template.has_resource_properties("Foo::Bar", {
-            "Fred": Match.array_with(["Flob"])
+            "Fred": {
+                "Wobble": [Match.any_value(), Match.any_value()]
+            }
         })
         
         # The following will throw an assertion error
-        template.has_resource_properties("Foo::Bar", Match.object_like({
-            "Fred": Match.array_with(["Wobble"])
-        }))
+        template.has_resource_properties("Foo::Bar", {
+            "Fred": {
+                "Wimble": Match.any_value()
+            }
+        })
     '''
 
     def __init__(self) -> None:
@@ -1328,6 +1388,80 @@ class _MatcherProxy(Matcher):
 typing.cast(typing.Any, Matcher).__jsii_proxy_class__ = lambda : _MatcherProxy
 
 
+class Tags(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.assertions.Tags"):
+    '''Allows assertions on the tags associated with a synthesized CDK stack's manifest.
+
+    Stack tags are not part of the synthesized template, so can only be
+    checked from the manifest in this manner.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        tags = Tags.from_stack(stack)
+        
+        # using a default 'objectLike' Matcher
+        tags.has_values({
+            "tag-name": "tag-value"
+        })
+        
+        # ... with Matchers embedded
+        tags.has_values({
+            "tag-name": Match.string_like_regexp("value")
+        })
+        
+        # or another object Matcher at the top level
+        tags.has_values(Match.object_equals({
+            "tag-name": Match.any_value()
+        }))
+    '''
+
+    @jsii.member(jsii_name="fromStack")
+    @builtins.classmethod
+    def from_stack(cls, stack: _Stack_2866e57f) -> "Tags":
+        '''Find tags associated with a synthesized CDK ``Stack``.
+
+        :param stack: the CDK Stack to find tags on.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__38acc2085aca209d4ba0849d7a04a1d024d47494c951663654a83bb9b25aa963)
+            check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
+        return typing.cast("Tags", jsii.sinvoke(cls, "fromStack", [stack]))
+
+    @jsii.member(jsii_name="all")
+    def all(self) -> typing.Mapping[builtins.str, builtins.str]:
+        '''Get the tags associated with the manifest.
+
+        This will be an empty object if
+        no tags were supplied.
+
+        :return: The tags associated with the stack's synthesized manifest.
+        '''
+        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "all", []))
+
+    @jsii.member(jsii_name="hasNone")
+    def has_none(self) -> None:
+        '''Assert that the there are no tags associated with the synthesized CDK Stack's manifest.
+
+        This is a convenience method over ``hasValues(Match.exact({}))``, and is
+        present because the more obvious method of detecting no tags
+        (``Match.absent()``) will not work. Manifests default the tag set to an empty
+        object.
+        '''
+        return typing.cast(None, jsii.invoke(self, "hasNone", []))
+
+    @jsii.member(jsii_name="hasValues")
+    def has_values(self, tags: typing.Any) -> None:
+        '''Assert that the given Matcher or object matches the tags associated with the synthesized CDK Stack's manifest.
+
+        :param tags: the expected set of tags. This should be a string or Matcher object.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__62e9347d457a951d50880cd16c1eee01eecf6d2b9875a6a7a907d3dd1d5de960)
+            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+        return typing.cast(None, jsii.invoke(self, "hasValues", [tags]))
+
+
 class Template(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.assertions.Template"):
     '''Suite of assertions that can be run on a CDK stack.
 
@@ -1865,6 +1999,7 @@ __all__ = [
     "MatchFailure",
     "MatchResult",
     "Matcher",
+    "Tags",
     "Template",
     "TemplateParsingOptions",
 ]
@@ -2039,6 +2174,18 @@ def _typecheckingstub__4a8e18e5d3147fdd105018b28e92d58ac6230fc3d6ea5c23d1d4328a3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__38acc2085aca209d4ba0849d7a04a1d024d47494c951663654a83bb9b25aa963(
+    stack: _Stack_2866e57f,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__62e9347d457a951d50880cd16c1eee01eecf6d2b9875a6a7a907d3dd1d5de960(
+    tags: typing.Any,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c6531cbb828e6143d2d6e79da05413d429d384d7cb2bdd314dfee1e6bb870758(
     template: typing.Mapping[builtins.str, typing.Any],
     *,

{aws-cdk-lib-2.136.1 → aws-cdk-lib-2.137.0}/src/aws_cdk/aws_cloudfront/__init__.py

@@ -553,14 +553,28 @@ To create an empty Key Value Store:
 store = cloudfront.KeyValueStore(self, "KeyValueStore")
 ```
 
-To also include an initial set of value, the `source` property can be specified. For the
-structure of this file, see [Creating a file of key value pairs](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/kvs-with-functions-create-s3-kvp.html).
+To also include an initial set of values, the `source` property can be specified, either from a
+local file or an inline string. For the structure of this file, see [Creating a file of key value pairs](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/kvs-with-functions-create-s3-kvp.html).
 
 ```python
-store = cloudfront.KeyValueStore(self, "KeyValueStore",
-    key_value_store_name="KeyValueStore",
+store_asset = cloudfront.KeyValueStore(self, "KeyValueStoreAsset",
+    key_value_store_name="KeyValueStoreAsset",
     source=cloudfront.ImportSource.from_asset("path-to-data.json")
 )
+
+store_inline = cloudfront.KeyValueStore(self, "KeyValueStoreInline",
+    key_value_store_name="KeyValueStoreInline",
+    source=cloudfront.ImportSource.from_inline(JSON.stringify({
+        "data": [{
+            "key": "key1",
+            "value": "value1"
+        }, {
+            "key": "key2",
+            "value": "value2"
+        }
+        ]
+    }))
+)
 ```
 
 The Key Value Store can then be associated to a function using the `cloudfront-js-2.0` runtime
@@ -17521,10 +17535,24 @@ class ImportSource(
 
     Example::
 
-        store = cloudfront.KeyValueStore(self, "KeyValueStore",
-            key_value_store_name="KeyValueStore",
+        store_asset = cloudfront.KeyValueStore(self, "KeyValueStoreAsset",
+            key_value_store_name="KeyValueStoreAsset",
             source=cloudfront.ImportSource.from_asset("path-to-data.json")
         )
+        
+        store_inline = cloudfront.KeyValueStore(self, "KeyValueStoreInline",
+            key_value_store_name="KeyValueStoreInline",
+            source=cloudfront.ImportSource.from_inline(JSON.stringify({
+                "data": [{
+                    "key": "key1",
+                    "value": "value1"
+                }, {
+                    "key": "key2",
+                    "value": "value2"
+                }
+                ]
+            }))
+        )
     '''
 
     def __init__(self) -> None:
@@ -17591,6 +17619,18 @@ class ImportSource(
             check_type(argname="argument key", value=key, expected_type=type_hints["key"])
         return typing.cast("ImportSource", jsii.sinvoke(cls, "fromBucket", [bucket, key]))
 
+    @jsii.member(jsii_name="fromInline")
+    @builtins.classmethod
+    def from_inline(cls, data: builtins.str) -> "ImportSource":
+        '''An import source that uses an inline string.
+
+        :param data: the contents of the KeyValueStore.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a50e730aa8d5bb1d3041587df3389916448f52815ee319019e3ea67abaeb349d)
+            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
+        return typing.cast("ImportSource", jsii.sinvoke(cls, "fromInline", [data]))
+
 
 class _ImportSourceProxy(ImportSource):
     pass
@@ -17599,6 +17639,80 @@ class _ImportSourceProxy(ImportSource):
 typing.cast(typing.Any, ImportSource).__jsii_proxy_class__ = lambda : _ImportSourceProxy
 
 
+class InlineImportSource(
+    ImportSource,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_cloudfront.InlineImportSource",
+):
+    '''An import source from an inline string.
+
+    :exampleMetadata: fixture=_generated
+
+    Example::
+
+        # The code below shows an example of how to instantiate this type.
+        # The values are placeholders you should change.
+        import aws_cdk as cdk
+        from aws_cdk import aws_cloudfront as cloudfront
+        from aws_cdk import aws_iam as iam
+        
+        # docker_image: cdk.DockerImage
+        # grantable: iam.IGrantable
+        # local_bundling: cdk.ILocalBundling
+        
+        inline_import_source = cloudfront.InlineImportSource.from_asset("path",
+            asset_hash="assetHash",
+            asset_hash_type=cdk.AssetHashType.SOURCE,
+            bundling=cdk.BundlingOptions(
+                image=docker_image,
+        
+                # the properties below are optional
+                bundling_file_access=cdk.BundlingFileAccess.VOLUME_COPY,
+                command=["command"],
+                entrypoint=["entrypoint"],
+                environment={
+                    "environment_key": "environment"
+                },
+                local=local_bundling,
+                network="network",
+                output_type=cdk.BundlingOutput.ARCHIVED,
+                platform="platform",
+                security_opt="securityOpt",
+                user="user",
+                volumes=[cdk.DockerVolume(
+                    container_path="containerPath",
+                    host_path="hostPath",
+        
+                    # the properties below are optional
+                    consistency=cdk.DockerVolumeConsistency.CONSISTENT
+                )],
+                volumes_from=["volumesFrom"],
+                working_directory="workingDirectory"
+            ),
+            deploy_time=False,
+            exclude=["exclude"],
+            follow_symlinks=cdk.SymlinkFollowMode.NEVER,
+            ignore_mode=cdk.IgnoreMode.GLOB,
+            readers=[grantable]
+        )
+    '''
+
+    def __init__(self, data: builtins.str) -> None:
+        '''
+        :param data: the contents of the KeyValueStore.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3f4f889ac66a946410766b5f47e88439c0d5d8056cd6bcd354c8251152edc50c)
+            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
+        jsii.create(self.__class__, self, [data])
+
+    @builtins.property
+    @jsii.member(jsii_name="data")
+    def data(self) -> builtins.str:
+        '''the contents of the KeyValueStore.'''
+        return typing.cast(builtins.str, jsii.get(self, "data"))
+
+
 @jsii.implements(IKeyGroup)
 class KeyGroup(
     _Resource_45bc6135,
@@ -17801,9 +17915,12 @@ class KeyValueStore(
 
     Example::
 
-        store = cloudfront.KeyValueStore(self, "KeyValueStore",
-            key_value_store_name="KeyValueStore",
-            source=cloudfront.ImportSource.from_asset("path-to-data.json")
+        store = cloudfront.KeyValueStore(self, "KeyValueStore")
+        cloudfront.Function(self, "Function",
+            code=cloudfront.FunctionCode.from_inline("function handler(event) { return event.request }"),
+            # Note that JS_2_0 must be used for Key Value Store support
+            runtime=cloudfront.FunctionRuntime.JS_2_0,
+            key_value_store=store
         )
     '''
 
@@ -17900,10 +18017,24 @@ class KeyValueStoreProps:
 
         Example::
 
-            store = cloudfront.KeyValueStore(self, "KeyValueStore",
-                key_value_store_name="KeyValueStore",
+            store_asset = cloudfront.KeyValueStore(self, "KeyValueStoreAsset",
+                key_value_store_name="KeyValueStoreAsset",
                 source=cloudfront.ImportSource.from_asset("path-to-data.json")
             )
+            
+            store_inline = cloudfront.KeyValueStore(self, "KeyValueStoreInline",
+                key_value_store_name="KeyValueStoreInline",
+                source=cloudfront.ImportSource.from_inline(JSON.stringify({
+                    "data": [{
+                        "key": "key1",
+                        "value": "value1"
+                    }, {
+                        "key": "key2",
+                        "value": "value2"
+                    }
+                    ]
+                }))
+            )
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__0885cf023551545b14a4696bf116b851a0c7733cc2987782ba95a29b134a062e)
@@ -21536,12 +21667,49 @@ class S3ImportSource(
 
         # The code below shows an example of how to instantiate this type.
         # The values are placeholders you should change.
+        import aws_cdk as cdk
         from aws_cdk import aws_cloudfront as cloudfront
-        from aws_cdk import aws_s3 as s3
+        from aws_cdk import aws_iam as iam
+        
+        # docker_image: cdk.DockerImage
+        # grantable: iam.IGrantable
+        # local_bundling: cdk.ILocalBundling
         
-        # bucket: s3.Bucket
+        s3_import_source = cloudfront.S3ImportSource.from_asset("path",
+            asset_hash="assetHash",
+            asset_hash_type=cdk.AssetHashType.SOURCE,
+            bundling=cdk.BundlingOptions(
+                image=docker_image,
         
-        s3_import_source = cloudfront.S3ImportSource(bucket, "key")
+                # the properties below are optional
+                bundling_file_access=cdk.BundlingFileAccess.VOLUME_COPY,
+                command=["command"],
+                entrypoint=["entrypoint"],
+                environment={
+                    "environment_key": "environment"
+                },
+                local=local_bundling,
+                network="network",
+                output_type=cdk.BundlingOutput.ARCHIVED,
+                platform="platform",
+                security_opt="securityOpt",
+                user="user",
+                volumes=[cdk.DockerVolume(
+                    container_path="containerPath",
+                    host_path="hostPath",
+        
+                    # the properties below are optional
+                    consistency=cdk.DockerVolumeConsistency.CONSISTENT
+                )],
+                volumes_from=["volumesFrom"],
+                working_directory="workingDirectory"
+            ),
+            deploy_time=False,
+            exclude=["exclude"],
+            follow_symlinks=cdk.SymlinkFollowMode.NEVER,
+            ignore_mode=cdk.IgnoreMode.GLOB,
+            readers=[grantable]
+        )
     '''
 
     def __init__(self, bucket: _IBucket_42e086fd, key: builtins.str) -> None:
@@ -22314,7 +22482,7 @@ class AssetImportSource(
         # grantable: iam.IGrantable
         # local_bundling: cdk.ILocalBundling
         
-        asset_import_source = cloudfront.AssetImportSource("path",
+        asset_import_source = cloudfront.AssetImportSource.from_asset("path",
             asset_hash="assetHash",
             asset_hash_type=cdk.AssetHashType.SOURCE,
             bundling=cdk.BundlingOptions(
@@ -23793,6 +23961,7 @@ __all__ = [
     "IRealtimeLogConfig",
     "IResponseHeadersPolicy",
     "ImportSource",
+    "InlineImportSource",
     "KeyGroup",
     "KeyGroupProps",
     "KeyValueStore",
@@ -25437,6 +25606,18 @@ def _typecheckingstub__199a9d2f509e6bf2ce32ccd58ce284ca48a05841123773473504a43c3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a50e730aa8d5bb1d3041587df3389916448f52815ee319019e3ea67abaeb349d(
+    data: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__3f4f889ac66a946410766b5f47e88439c0d5d8056cd6bcd354c8251152edc50c(
+    data: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__8c6747d6cf01bdf872790a9315f48bb3e3363e1c57d3a822e5cf812d017c9661(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,