eoapi-cdk 8.2.0__tar.gz → 8.2.2__tar.gz

{eoapi_cdk-8.2.0/src/eoapi_cdk.egg-info → eoapi_cdk-8.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eoapi-cdk
-Version: 8.2.0
+Version: 8.2.2
 Summary: A set of constructs deploying pgSTAC with CDK
 Home-page: https://github.com/developmentseed/eoapi-cdk.git
 Author: Anthony Lukach<anthony@developmentseed.org>

{eoapi_cdk-8.2.0 → eoapi_cdk-8.2.2}/setup.py

@@ -5,7 +5,7 @@ kwargs = json.loads(
     """
 {
     "name": "eoapi-cdk",
-    "version": "8.2.0",
+    "version": "8.2.2",
     "description": "A set of constructs deploying pgSTAC with CDK",
     "license": "ISC",
     "url": "https://github.com/developmentseed/eoapi-cdk.git",
@@ -26,7 +26,7 @@ kwargs = json.loads(
     ],
     "package_data": {
         "eoapi_cdk._jsii": [
-            "eoapi-cdk@8.2.0.jsii.tgz"
+            "eoapi-cdk@8.2.2.jsii.tgz"
         ],
         "eoapi_cdk": [
             "py.typed"

{eoapi_cdk-8.2.0 → eoapi_cdk-8.2.2}/src/eoapi_cdk/__init__.py

@@ -3024,23 +3024,29 @@ class StacItemLoader(
         pgstac_db: PgStacDatabase,
         batch_size: typing.Optional[jsii.Number] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        lambda_function_options: typing.Any = None,
         lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
         lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
         max_batching_window_minutes: typing.Optional[jsii.Number] = None,
         max_concurrency: typing.Optional[jsii.Number] = None,
         memory_size: typing.Optional[jsii.Number] = None,
+        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
     ) -> None:
         '''
         :param scope: -
         :param id: -
         :param pgstac_db: (experimental) The PgSTAC database instance to load items into. This database must have the pgstac extension installed and be properly configured with collections before items can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
         :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC items that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
-        :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags.
+        :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags. If you want to enable the option to upload a boilerplate collection record in the event that the collection record does not yet exist for an item that is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
+        :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
         :param lambda_runtime: (experimental) The lambda runtime to use for the item loading function. The function is implemented in Python and uses pypgstac for database operations. Ensure the runtime version is compatible with the pgstac version specified in the database configuration. Default: lambda.Runtime.PYTHON_3_11
         :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` items and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
         :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of items. This prevents items from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring items are processed in a timely manner regardless of volume. Default: 1
         :param max_concurrency: (experimental) Maximum concurrent executions for the StacItemLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
         :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC items, especially for memory-intensive database operations. Default: 1024
+        :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
+        :param vpc: (experimental) VPC into which the lambda should be deployed.
 
         :stability: experimental
         '''
@@ -3052,11 +3058,14 @@ class StacItemLoader(
             pgstac_db=pgstac_db,
             batch_size=batch_size,
             environment=environment,
+            lambda_function_options=lambda_function_options,
             lambda_runtime=lambda_runtime,
             lambda_timeout_seconds=lambda_timeout_seconds,
             max_batching_window_minutes=max_batching_window_minutes,
             max_concurrency=max_concurrency,
             memory_size=memory_size,
+            subnet_selection=subnet_selection,
+            vpc=vpc,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -3139,11 +3148,14 @@ class StacItemLoader(
         "pgstac_db": "pgstacDb",
         "batch_size": "batchSize",
         "environment": "environment",
+        "lambda_function_options": "lambdaFunctionOptions",
         "lambda_runtime": "lambdaRuntime",
         "lambda_timeout_seconds": "lambdaTimeoutSeconds",
         "max_batching_window_minutes": "maxBatchingWindowMinutes",
         "max_concurrency": "maxConcurrency",
         "memory_size": "memorySize",
+        "subnet_selection": "subnetSelection",
+        "vpc": "vpc",
     },
 )
 class StacItemLoaderProps:
@@ -3153,11 +3165,14 @@ class StacItemLoaderProps:
         pgstac_db: PgStacDatabase,
         batch_size: typing.Optional[jsii.Number] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        lambda_function_options: typing.Any = None,
         lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
         lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
         max_batching_window_minutes: typing.Optional[jsii.Number] = None,
         max_concurrency: typing.Optional[jsii.Number] = None,
         memory_size: typing.Optional[jsii.Number] = None,
+        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
     ) -> None:
         '''(experimental) Configuration properties for the StacItemLoader construct.
 
@@ -3172,12 +3187,15 @@ class StacItemLoaderProps:
 
         :param pgstac_db: (experimental) The PgSTAC database instance to load items into. This database must have the pgstac extension installed and be properly configured with collections before items can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
         :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC items that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
-        :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags.
+        :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags. If you want to enable the option to upload a boilerplate collection record in the event that the collection record does not yet exist for an item that is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
+        :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
         :param lambda_runtime: (experimental) The lambda runtime to use for the item loading function. The function is implemented in Python and uses pypgstac for database operations. Ensure the runtime version is compatible with the pgstac version specified in the database configuration. Default: lambda.Runtime.PYTHON_3_11
         :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` items and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
         :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of items. This prevents items from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring items are processed in a timely manner regardless of volume. Default: 1
         :param max_concurrency: (experimental) Maximum concurrent executions for the StacItemLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
         :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC items, especially for memory-intensive database operations. Default: 1024
+        :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
+        :param vpc: (experimental) VPC into which the lambda should be deployed.
 
         :stability: experimental
 
@@ -3190,16 +3208,21 @@ class StacItemLoaderProps:
               lambdaTimeoutSeconds: 300
             });
         '''
+        if isinstance(subnet_selection, dict):
+            subnet_selection = _aws_cdk_aws_ec2_ceddda9d.SubnetSelection(**subnet_selection)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__4bbe16b8ca579680ab8c75903813675de5c4f4e8877137194262298af5f8093d)
             check_type(argname="argument pgstac_db", value=pgstac_db, expected_type=type_hints["pgstac_db"])
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
+            check_type(argname="argument lambda_function_options", value=lambda_function_options, expected_type=type_hints["lambda_function_options"])
             check_type(argname="argument lambda_runtime", value=lambda_runtime, expected_type=type_hints["lambda_runtime"])
             check_type(argname="argument lambda_timeout_seconds", value=lambda_timeout_seconds, expected_type=type_hints["lambda_timeout_seconds"])
             check_type(argname="argument max_batching_window_minutes", value=max_batching_window_minutes, expected_type=type_hints["max_batching_window_minutes"])
             check_type(argname="argument max_concurrency", value=max_concurrency, expected_type=type_hints["max_concurrency"])
             check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
+            check_type(argname="argument subnet_selection", value=subnet_selection, expected_type=type_hints["subnet_selection"])
+            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "pgstac_db": pgstac_db,
         }
@@ -3207,6 +3230,8 @@ class StacItemLoaderProps:
             self._values["batch_size"] = batch_size
         if environment is not None:
             self._values["environment"] = environment
+        if lambda_function_options is not None:
+            self._values["lambda_function_options"] = lambda_function_options
         if lambda_runtime is not None:
             self._values["lambda_runtime"] = lambda_runtime
         if lambda_timeout_seconds is not None:
@@ -3217,6 +3242,10 @@ class StacItemLoaderProps:
             self._values["max_concurrency"] = max_concurrency
         if memory_size is not None:
             self._values["memory_size"] = memory_size
+        if subnet_selection is not None:
+            self._values["subnet_selection"] = subnet_selection
+        if vpc is not None:
+            self._values["vpc"] = vpc
 
     @builtins.property
     def pgstac_db(self) -> PgStacDatabase:
@@ -3262,11 +3291,26 @@ class StacItemLoaderProps:
         These will be merged with the default environment variables including
         PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags.
 
+        If you want to enable the option to upload a boilerplate collection record
+        in the event that the collection record does not yet exist for an item that
+        is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
+
         :stability: experimental
         '''
         result = self._values.get("environment")
         return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
 
+    @builtins.property
+    def lambda_function_options(self) -> typing.Any:
+        '''(experimental) Can be used to override the default lambda function properties.
+
+        :default: - defined in the construct.
+
+        :stability: experimental
+        '''
+        result = self._values.get("lambda_function_options")
+        return typing.cast(typing.Any, result)
+
     @builtins.property
     def lambda_runtime(self) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime]:
         '''(experimental) The lambda runtime to use for the item loading function.
@@ -3346,6 +3390,26 @@ class StacItemLoaderProps:
         result = self._values.get("memory_size")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def subnet_selection(
+        self,
+    ) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection]:
+        '''(experimental) Subnet into which the lambda should be deployed.
+
+        :stability: experimental
+        '''
+        result = self._values.get("subnet_selection")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection], result)
+
+    @builtins.property
+    def vpc(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc]:
+        '''(experimental) VPC into which the lambda should be deployed.
+
+        :stability: experimental
+        '''
+        result = self._values.get("vpc")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -3499,10 +3563,13 @@ class StactoolsItemGenerator(
         item_load_topic_arn: builtins.str,
         batch_size: typing.Optional[jsii.Number] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        lambda_function_options: typing.Any = None,
         lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
         lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
         max_concurrency: typing.Optional[jsii.Number] = None,
         memory_size: typing.Optional[jsii.Number] = None,
+        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
     ) -> None:
         '''
         :param scope: -
@@ -3510,10 +3577,13 @@ class StactoolsItemGenerator(
         :param item_load_topic_arn: (experimental) ARN of the SNS topic to publish generated items to. This is typically the topic from a StacItemLoader construct. Generated STAC items will be published here for downstream processing and database insertion.
         :param batch_size: (experimental) SQS batch size for lambda event source. This determines how many generation requests are processed together in a single lambda invocation. Unlike the loader, generation typically processes items individually, so smaller batch sizes are common. Default: 10
         :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with default environment variables including ITEM_LOAD_TOPIC_ARN and LOG_LEVEL. Use this for custom configuration or to pass credentials for external data sources.
+        :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
         :param lambda_runtime: (experimental) The lambda runtime to use for the item generation function. The function is containerized using Docker and can accommodate various stactools packages. The runtime version should be compatible with the packages you plan to use for STAC item generation. Default: lambda.Runtime.PYTHON_3_11
         :param lambda_timeout_seconds: (experimental) The timeout for the item generation lambda in seconds. This should accommodate the time needed to: - Install stactools packages using uvx - Download and process source data - Generate STAC metadata - Publish results to SNS The SQS visibility timeout will be set to this value plus 10 seconds. Default: 120
         :param max_concurrency: (experimental) Maximum number of concurrent executions. This controls how many item generation tasks can run simultaneously. Higher concurrency enables faster processing of large batches but may strain downstream systems or external data sources. Default: 100
         :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may be needed for processing large geospatial datasets or when stactools packages have high memory requirements. More memory also provides proportionally more CPU power. Default: 1024
+        :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
+        :param vpc: (experimental) VPC into which the lambda should be deployed.
 
         :stability: experimental
         '''
@@ -3525,10 +3595,13 @@ class StactoolsItemGenerator(
             item_load_topic_arn=item_load_topic_arn,
             batch_size=batch_size,
             environment=environment,
+            lambda_function_options=lambda_function_options,
             lambda_runtime=lambda_runtime,
             lambda_timeout_seconds=lambda_timeout_seconds,
             max_concurrency=max_concurrency,
             memory_size=memory_size,
+            subnet_selection=subnet_selection,
+            vpc=vpc,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -3592,10 +3665,13 @@ class StactoolsItemGenerator(
         "item_load_topic_arn": "itemLoadTopicArn",
         "batch_size": "batchSize",
         "environment": "environment",
+        "lambda_function_options": "lambdaFunctionOptions",
         "lambda_runtime": "lambdaRuntime",
         "lambda_timeout_seconds": "lambdaTimeoutSeconds",
         "max_concurrency": "maxConcurrency",
         "memory_size": "memorySize",
+        "subnet_selection": "subnetSelection",
+        "vpc": "vpc",
     },
 )
 class StactoolsItemGeneratorProps:
@@ -3605,10 +3681,13 @@ class StactoolsItemGeneratorProps:
         item_load_topic_arn: builtins.str,
         batch_size: typing.Optional[jsii.Number] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        lambda_function_options: typing.Any = None,
         lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
         lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
         max_concurrency: typing.Optional[jsii.Number] = None,
         memory_size: typing.Optional[jsii.Number] = None,
+        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
     ) -> None:
         '''(experimental) Configuration properties for the StactoolsItemGenerator construct.
 
@@ -3620,10 +3699,13 @@ class StactoolsItemGeneratorProps:
         :param item_load_topic_arn: (experimental) ARN of the SNS topic to publish generated items to. This is typically the topic from a StacItemLoader construct. Generated STAC items will be published here for downstream processing and database insertion.
         :param batch_size: (experimental) SQS batch size for lambda event source. This determines how many generation requests are processed together in a single lambda invocation. Unlike the loader, generation typically processes items individually, so smaller batch sizes are common. Default: 10
         :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with default environment variables including ITEM_LOAD_TOPIC_ARN and LOG_LEVEL. Use this for custom configuration or to pass credentials for external data sources.
+        :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
         :param lambda_runtime: (experimental) The lambda runtime to use for the item generation function. The function is containerized using Docker and can accommodate various stactools packages. The runtime version should be compatible with the packages you plan to use for STAC item generation. Default: lambda.Runtime.PYTHON_3_11
         :param lambda_timeout_seconds: (experimental) The timeout for the item generation lambda in seconds. This should accommodate the time needed to: - Install stactools packages using uvx - Download and process source data - Generate STAC metadata - Publish results to SNS The SQS visibility timeout will be set to this value plus 10 seconds. Default: 120
         :param max_concurrency: (experimental) Maximum number of concurrent executions. This controls how many item generation tasks can run simultaneously. Higher concurrency enables faster processing of large batches but may strain downstream systems or external data sources. Default: 100
         :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may be needed for processing large geospatial datasets or when stactools packages have high memory requirements. More memory also provides proportionally more CPU power. Default: 1024
+        :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
+        :param vpc: (experimental) VPC into which the lambda should be deployed.
 
         :stability: experimental
 
@@ -3636,15 +3718,20 @@ class StactoolsItemGeneratorProps:
               batchSize: 10
             });
         '''
+        if isinstance(subnet_selection, dict):
+            subnet_selection = _aws_cdk_aws_ec2_ceddda9d.SubnetSelection(**subnet_selection)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__6b9e5f6f8807be7e134c778699faa426c2851b57b5925a17e70c484a0a1cb82c)
             check_type(argname="argument item_load_topic_arn", value=item_load_topic_arn, expected_type=type_hints["item_load_topic_arn"])
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
+            check_type(argname="argument lambda_function_options", value=lambda_function_options, expected_type=type_hints["lambda_function_options"])
             check_type(argname="argument lambda_runtime", value=lambda_runtime, expected_type=type_hints["lambda_runtime"])
             check_type(argname="argument lambda_timeout_seconds", value=lambda_timeout_seconds, expected_type=type_hints["lambda_timeout_seconds"])
             check_type(argname="argument max_concurrency", value=max_concurrency, expected_type=type_hints["max_concurrency"])
             check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
+            check_type(argname="argument subnet_selection", value=subnet_selection, expected_type=type_hints["subnet_selection"])
+            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "item_load_topic_arn": item_load_topic_arn,
         }
@@ -3652,6 +3739,8 @@ class StactoolsItemGeneratorProps:
             self._values["batch_size"] = batch_size
         if environment is not None:
             self._values["environment"] = environment
+        if lambda_function_options is not None:
+            self._values["lambda_function_options"] = lambda_function_options
         if lambda_runtime is not None:
             self._values["lambda_runtime"] = lambda_runtime
         if lambda_timeout_seconds is not None:
@@ -3660,6 +3749,10 @@ class StactoolsItemGeneratorProps:
             self._values["max_concurrency"] = max_concurrency
         if memory_size is not None:
             self._values["memory_size"] = memory_size
+        if subnet_selection is not None:
+            self._values["subnet_selection"] = subnet_selection
+        if vpc is not None:
+            self._values["vpc"] = vpc
 
     @builtins.property
     def item_load_topic_arn(self) -> builtins.str:
@@ -3705,6 +3798,17 @@ class StactoolsItemGeneratorProps:
         result = self._values.get("environment")
         return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
 
+    @builtins.property
+    def lambda_function_options(self) -> typing.Any:
+        '''(experimental) Can be used to override the default lambda function properties.
+
+        :default: - defined in the construct.
+
+        :stability: experimental
+        '''
+        result = self._values.get("lambda_function_options")
+        return typing.cast(typing.Any, result)
+
     @builtins.property
     def lambda_runtime(self) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime]:
         '''(experimental) The lambda runtime to use for the item generation function.
@@ -3770,6 +3874,26 @@ class StactoolsItemGeneratorProps:
         result = self._values.get("memory_size")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def subnet_selection(
+        self,
+    ) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection]:
+        '''(experimental) Subnet into which the lambda should be deployed.
+
+        :stability: experimental
+        '''
+        result = self._values.get("subnet_selection")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection], result)
+
+    @builtins.property
+    def vpc(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc]:
+        '''(experimental) VPC into which the lambda should be deployed.
+
+        :stability: experimental
+        '''
+        result = self._values.get("vpc")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -4626,11 +4750,14 @@ def _typecheckingstub__3993e1684b5582edef005457882c4cfe3c53062e1f47dc584d35a9cfa
     pgstac_db: PgStacDatabase,
     batch_size: typing.Optional[jsii.Number] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    lambda_function_options: typing.Any = None,
     lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
     lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
     max_batching_window_minutes: typing.Optional[jsii.Number] = None,
     max_concurrency: typing.Optional[jsii.Number] = None,
     memory_size: typing.Optional[jsii.Number] = None,
+    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -4640,11 +4767,14 @@ def _typecheckingstub__4bbe16b8ca579680ab8c75903813675de5c4f4e8877137194262298af
     pgstac_db: PgStacDatabase,
     batch_size: typing.Optional[jsii.Number] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    lambda_function_options: typing.Any = None,
     lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
     lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
     max_batching_window_minutes: typing.Optional[jsii.Number] = None,
     max_concurrency: typing.Optional[jsii.Number] = None,
     memory_size: typing.Optional[jsii.Number] = None,
+    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -4656,10 +4786,13 @@ def _typecheckingstub__243b4e1875cc07228a55b3a2ffc4c24ad6d9b88594875765ecf973953
     item_load_topic_arn: builtins.str,
     batch_size: typing.Optional[jsii.Number] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    lambda_function_options: typing.Any = None,
     lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
     lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
     max_concurrency: typing.Optional[jsii.Number] = None,
     memory_size: typing.Optional[jsii.Number] = None,
+    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -4669,10 +4802,13 @@ def _typecheckingstub__6b9e5f6f8807be7e134c778699faa426c2851b57b5925a17e70c484a0
     item_load_topic_arn: builtins.str,
     batch_size: typing.Optional[jsii.Number] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    lambda_function_options: typing.Any = None,
     lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
     lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
     max_concurrency: typing.Optional[jsii.Number] = None,
     memory_size: typing.Optional[jsii.Number] = None,
+    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
 ) -> None:
     """Type checking stubs"""
     pass

{eoapi_cdk-8.2.0 → eoapi_cdk-8.2.2}/src/eoapi_cdk/_jsii/__init__.py

@@ -32,7 +32,7 @@ import aws_cdk._jsii
 import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "eoapi-cdk", "8.2.0", __name__[0:-6], "eoapi-cdk@8.2.0.jsii.tgz"
+    "eoapi-cdk", "8.2.2", __name__[0:-6], "eoapi-cdk@8.2.2.jsii.tgz"
 )
 
 __all__ = [

{eoapi_cdk-8.2.0 → eoapi_cdk-8.2.2/src/eoapi_cdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eoapi-cdk
-Version: 8.2.0
+Version: 8.2.2
 Summary: A set of constructs deploying pgSTAC with CDK
 Home-page: https://github.com/developmentseed/eoapi-cdk.git
 Author: Anthony Lukach<anthony@developmentseed.org>

{eoapi_cdk-8.2.0 → eoapi_cdk-8.2.2}/src/eoapi_cdk.egg-info/SOURCES.txt

@@ -11,4 +11,4 @@ src/eoapi_cdk.egg-info/dependency_links.txt
 src/eoapi_cdk.egg-info/requires.txt
 src/eoapi_cdk.egg-info/top_level.txt
 src/eoapi_cdk/_jsii/__init__.py
-src/eoapi_cdk/_jsii/eoapi-cdk@8.2.0.jsii.tgz
+src/eoapi_cdk/_jsii/eoapi-cdk@8.2.2.jsii.tgz