pulumi-datarobot 0.5.4__tar.gz → 0.7.2__tar.gz

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi_datarobot
-Version: 0.5.4
+Version: 0.7.2
 Summary: A Pulumi package for creating and managing DataRobot resources.
 Home-page: https://www.datarobot.com
 License: Apache-2.0

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/pulumi_datarobot/__init__.py

@@ -11,6 +11,7 @@ from .aws_credential import *
 from .basic_credential import *
 from .batch_prediction_job_definition import *
 from .custom_application import *
+from .custom_application_from_environment import *
 from .custom_job import *
 from .custom_metric_from_job import *
 from .custom_metric_job import *
@@ -97,6 +98,14 @@ _utilities.register(
    "datarobot:index/customApplication:CustomApplication": "CustomApplication"
   }
  },
+ {
+  "pkg": "datarobot",
+  "mod": "index/customApplicationFromEnvironment",
+  "fqn": "pulumi_datarobot",
+  "classes": {
+   "datarobot:index/customApplicationFromEnvironment:CustomApplicationFromEnvironment": "CustomApplicationFromEnvironment"
+  }
+ },
  {
   "pkg": "datarobot",
   "mod": "index/customJob",

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/pulumi_datarobot/_inputs.py

@@ -15,6 +15,8 @@ else:
 from . import _utilities
 
 __all__ = [
+    'ApplicationSourceResourcesArgs',
+    'ApplicationSourceResourcesArgsDict',
     'ApplicationSourceRuntimeParameterValueArgs',
     'ApplicationSourceRuntimeParameterValueArgsDict',
     'BatchPredictionJobDefinitionCsvSettingsArgs',
@@ -125,6 +127,78 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class ApplicationSourceResourcesArgsDict(TypedDict):
+        replicas: NotRequired[pulumi.Input[int]]
+        """
+        The replicas for the Application Source.
+        """
+        resource_label: NotRequired[pulumi.Input[str]]
+        """
+        The resource label for the Application Source.
+        """
+        session_affinity: NotRequired[pulumi.Input[bool]]
+        """
+        The session affinity for the Application Source.
+        """
+elif False:
+    ApplicationSourceResourcesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ApplicationSourceResourcesArgs:
+    def __init__(__self__, *,
+                 replicas: Optional[pulumi.Input[int]] = None,
+                 resource_label: Optional[pulumi.Input[str]] = None,
+                 session_affinity: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[int] replicas: The replicas for the Application Source.
+        :param pulumi.Input[str] resource_label: The resource label for the Application Source.
+        :param pulumi.Input[bool] session_affinity: The session affinity for the Application Source.
+        """
+        if replicas is not None:
+            pulumi.set(__self__, "replicas", replicas)
+        if resource_label is not None:
+            pulumi.set(__self__, "resource_label", resource_label)
+        if session_affinity is not None:
+            pulumi.set(__self__, "session_affinity", session_affinity)
+
+    @property
+    @pulumi.getter
+    def replicas(self) -> Optional[pulumi.Input[int]]:
+        """
+        The replicas for the Application Source.
+        """
+        return pulumi.get(self, "replicas")
+
+    @replicas.setter
+    def replicas(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "replicas", value)
+
+    @property
+    @pulumi.getter(name="resourceLabel")
+    def resource_label(self) -> Optional[pulumi.Input[str]]:
+        """
+        The resource label for the Application Source.
+        """
+        return pulumi.get(self, "resource_label")
+
+    @resource_label.setter
+    def resource_label(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_label", value)
+
+    @property
+    @pulumi.getter(name="sessionAffinity")
+    def session_affinity(self) -> Optional[pulumi.Input[bool]]:
+        """
+        The session affinity for the Application Source.
+        """
+        return pulumi.get(self, "session_affinity")
+
+    @session_affinity.setter
+    def session_affinity(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "session_affinity", value)
+
+
 if not MYPY:
     class ApplicationSourceRuntimeParameterValueArgsDict(TypedDict):
         key: pulumi.Input[str]

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/pulumi_datarobot/application_source.py

@@ -26,7 +26,7 @@ class ApplicationSourceArgs:
                  files: Optional[Any] = None,
                  folder_path: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 replicas: Optional[pulumi.Input[int]] = None,
+                 resources: Optional[pulumi.Input['ApplicationSourceResourcesArgs']] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSourceRuntimeParameterValueArgs']]]] = None):
         """
         The set of arguments for constructing a ApplicationSource resource.
@@ -35,7 +35,7 @@ class ApplicationSourceArgs:
         :param Any files: The list of tuples, where values in each tuple are the local filesystem path and the path the file should be placed in the Application Source. If list is of strings, then basenames will be used for tuples.
         :param pulumi.Input[str] folder_path: The path to a folder containing files to build the Application Source. Each file in the folder is uploaded under path relative to a folder path.
         :param pulumi.Input[str] name: The name of the Application Source.
-        :param pulumi.Input[int] replicas: The replicas for the Application Source.
+        :param pulumi.Input['ApplicationSourceResourcesArgs'] resources: The resources for the Application Source.
         :param pulumi.Input[Sequence[pulumi.Input['ApplicationSourceRuntimeParameterValueArgs']]] runtime_parameter_values: The runtime parameter values for the Application Source.
         """
         if base_environment_id is not None:
@@ -48,8 +48,8 @@ class ApplicationSourceArgs:
             pulumi.set(__self__, "folder_path", folder_path)
         if name is not None:
             pulumi.set(__self__, "name", name)
-        if replicas is not None:
-            pulumi.set(__self__, "replicas", replicas)
+        if resources is not None:
+            pulumi.set(__self__, "resources", resources)
         if runtime_parameter_values is not None:
             pulumi.set(__self__, "runtime_parameter_values", runtime_parameter_values)
 
@@ -115,15 +115,15 @@ class ApplicationSourceArgs:
 
     @property
     @pulumi.getter
-    def replicas(self) -> Optional[pulumi.Input[int]]:
+    def resources(self) -> Optional[pulumi.Input['ApplicationSourceResourcesArgs']]:
         """
-        The replicas for the Application Source.
+        The resources for the Application Source.
         """
-        return pulumi.get(self, "replicas")
+        return pulumi.get(self, "resources")
 
-    @replicas.setter
-    def replicas(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "replicas", value)
+    @resources.setter
+    def resources(self, value: Optional[pulumi.Input['ApplicationSourceResourcesArgs']]):
+        pulumi.set(self, "resources", value)
 
     @property
     @pulumi.getter(name="runtimeParameterValues")
@@ -148,7 +148,7 @@ class _ApplicationSourceState:
                  folder_path: Optional[pulumi.Input[str]] = None,
                  folder_path_hash: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 replicas: Optional[pulumi.Input[int]] = None,
+                 resources: Optional[pulumi.Input['ApplicationSourceResourcesArgs']] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSourceRuntimeParameterValueArgs']]]] = None,
                  version_id: Optional[pulumi.Input[str]] = None):
         """
@@ -160,7 +160,7 @@ class _ApplicationSourceState:
         :param pulumi.Input[str] folder_path: The path to a folder containing files to build the Application Source. Each file in the folder is uploaded under path relative to a folder path.
         :param pulumi.Input[str] folder_path_hash: The hash of the folder path contents.
         :param pulumi.Input[str] name: The name of the Application Source.
-        :param pulumi.Input[int] replicas: The replicas for the Application Source.
+        :param pulumi.Input['ApplicationSourceResourcesArgs'] resources: The resources for the Application Source.
         :param pulumi.Input[Sequence[pulumi.Input['ApplicationSourceRuntimeParameterValueArgs']]] runtime_parameter_values: The runtime parameter values for the Application Source.
         :param pulumi.Input[str] version_id: The version ID of the Application Source.
         """
@@ -178,8 +178,8 @@ class _ApplicationSourceState:
             pulumi.set(__self__, "folder_path_hash", folder_path_hash)
         if name is not None:
             pulumi.set(__self__, "name", name)
-        if replicas is not None:
-            pulumi.set(__self__, "replicas", replicas)
+        if resources is not None:
+            pulumi.set(__self__, "resources", resources)
         if runtime_parameter_values is not None:
             pulumi.set(__self__, "runtime_parameter_values", runtime_parameter_values)
         if version_id is not None:
@@ -271,15 +271,15 @@ class _ApplicationSourceState:
 
     @property
     @pulumi.getter
-    def replicas(self) -> Optional[pulumi.Input[int]]:
+    def resources(self) -> Optional[pulumi.Input['ApplicationSourceResourcesArgs']]:
         """
-        The replicas for the Application Source.
+        The resources for the Application Source.
         """
-        return pulumi.get(self, "replicas")
+        return pulumi.get(self, "resources")
 
-    @replicas.setter
-    def replicas(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "replicas", value)
+    @resources.setter
+    def resources(self, value: Optional[pulumi.Input['ApplicationSourceResourcesArgs']]):
+        pulumi.set(self, "resources", value)
 
     @property
     @pulumi.getter(name="runtimeParameterValues")
@@ -316,28 +316,12 @@ class ApplicationSource(pulumi.CustomResource):
                  files: Optional[Any] = None,
                  folder_path: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 replicas: Optional[pulumi.Input[int]] = None,
+                 resources: Optional[pulumi.Input[Union['ApplicationSourceResourcesArgs', 'ApplicationSourceResourcesArgsDict']]] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]]] = None,
                  __props__=None):
         """
         Application Source
 
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_datarobot as datarobot
-
-        example = datarobot.ApplicationSource("example",
-            base_environment_id="6542cd582a9d3d51bf4ac71e",
-            files=[
-                ["start-app.sh"],
-                ["streamlit-app.py"],
-            ])
-        pulumi.export("datarobotApplicationSourceId", example.id)
-        pulumi.export("datarobotApplicationSourceVersionId", example.version_id)
-        ```
-
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[str] base_environment_id: The ID of the base environment for the Application Source.
@@ -345,7 +329,7 @@ class ApplicationSource(pulumi.CustomResource):
         :param Any files: The list of tuples, where values in each tuple are the local filesystem path and the path the file should be placed in the Application Source. If list is of strings, then basenames will be used for tuples.
         :param pulumi.Input[str] folder_path: The path to a folder containing files to build the Application Source. Each file in the folder is uploaded under path relative to a folder path.
         :param pulumi.Input[str] name: The name of the Application Source.
-        :param pulumi.Input[int] replicas: The replicas for the Application Source.
+        :param pulumi.Input[Union['ApplicationSourceResourcesArgs', 'ApplicationSourceResourcesArgsDict']] resources: The resources for the Application Source.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]] runtime_parameter_values: The runtime parameter values for the Application Source.
         """
         ...
@@ -357,22 +341,6 @@ class ApplicationSource(pulumi.CustomResource):
         """
         Application Source
 
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_datarobot as datarobot
-
-        example = datarobot.ApplicationSource("example",
-            base_environment_id="6542cd582a9d3d51bf4ac71e",
-            files=[
-                ["start-app.sh"],
-                ["streamlit-app.py"],
-            ])
-        pulumi.export("datarobotApplicationSourceId", example.id)
-        pulumi.export("datarobotApplicationSourceVersionId", example.version_id)
-        ```
-
         :param str resource_name: The name of the resource.
         :param ApplicationSourceArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.
@@ -393,7 +361,7 @@ class ApplicationSource(pulumi.CustomResource):
                  files: Optional[Any] = None,
                  folder_path: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 replicas: Optional[pulumi.Input[int]] = None,
+                 resources: Optional[pulumi.Input[Union['ApplicationSourceResourcesArgs', 'ApplicationSourceResourcesArgsDict']]] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -409,7 +377,7 @@ class ApplicationSource(pulumi.CustomResource):
             __props__.__dict__["files"] = files
             __props__.__dict__["folder_path"] = folder_path
             __props__.__dict__["name"] = name
-            __props__.__dict__["replicas"] = replicas
+            __props__.__dict__["resources"] = resources
             __props__.__dict__["runtime_parameter_values"] = runtime_parameter_values
             __props__.__dict__["files_hashes"] = None
             __props__.__dict__["folder_path_hash"] = None
@@ -431,7 +399,7 @@ class ApplicationSource(pulumi.CustomResource):
             folder_path: Optional[pulumi.Input[str]] = None,
             folder_path_hash: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
-            replicas: Optional[pulumi.Input[int]] = None,
+            resources: Optional[pulumi.Input[Union['ApplicationSourceResourcesArgs', 'ApplicationSourceResourcesArgsDict']]] = None,
             runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]]] = None,
             version_id: Optional[pulumi.Input[str]] = None) -> 'ApplicationSource':
         """
@@ -448,7 +416,7 @@ class ApplicationSource(pulumi.CustomResource):
         :param pulumi.Input[str] folder_path: The path to a folder containing files to build the Application Source. Each file in the folder is uploaded under path relative to a folder path.
         :param pulumi.Input[str] folder_path_hash: The hash of the folder path contents.
         :param pulumi.Input[str] name: The name of the Application Source.
-        :param pulumi.Input[int] replicas: The replicas for the Application Source.
+        :param pulumi.Input[Union['ApplicationSourceResourcesArgs', 'ApplicationSourceResourcesArgsDict']] resources: The resources for the Application Source.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]] runtime_parameter_values: The runtime parameter values for the Application Source.
         :param pulumi.Input[str] version_id: The version ID of the Application Source.
         """
@@ -463,7 +431,7 @@ class ApplicationSource(pulumi.CustomResource):
         __props__.__dict__["folder_path"] = folder_path
         __props__.__dict__["folder_path_hash"] = folder_path_hash
         __props__.__dict__["name"] = name
-        __props__.__dict__["replicas"] = replicas
+        __props__.__dict__["resources"] = resources
         __props__.__dict__["runtime_parameter_values"] = runtime_parameter_values
         __props__.__dict__["version_id"] = version_id
         return ApplicationSource(resource_name, opts=opts, __props__=__props__)
@@ -526,11 +494,11 @@ class ApplicationSource(pulumi.CustomResource):
 
     @property
     @pulumi.getter
-    def replicas(self) -> pulumi.Output[int]:
+    def resources(self) -> pulumi.Output['outputs.ApplicationSourceResources']:
         """
-        The replicas for the Application Source.
+        The resources for the Application Source.
         """
-        return pulumi.get(self, "replicas")
+        return pulumi.get(self, "resources")
 
     @property
     @pulumi.getter(name="runtimeParameterValues")

pulumi_datarobot-0.7.2/pulumi_datarobot/custom_application_from_environment.py

@@ -0,0 +1,423 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = ['CustomApplicationFromEnvironmentArgs', 'CustomApplicationFromEnvironment']
+
+@pulumi.input_type
+class CustomApplicationFromEnvironmentArgs:
+    def __init__(__self__, *,
+                 environment_id: pulumi.Input[str],
+                 external_access_enabled: Optional[pulumi.Input[bool]] = None,
+                 external_access_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 use_case_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        The set of arguments for constructing a CustomApplicationFromEnvironment resource.
+        :param pulumi.Input[str] environment_id: The ID of the Execution Environment used to create the Custom Application.
+        :param pulumi.Input[bool] external_access_enabled: Whether external access is enabled for the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] external_access_recipients: The list of external email addresses that have access to the Custom Application.
+        :param pulumi.Input[str] name: The name of the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] use_case_ids: The list of Use Case IDs to add the Custom Application to.
+        """
+        pulumi.set(__self__, "environment_id", environment_id)
+        if external_access_enabled is not None:
+            pulumi.set(__self__, "external_access_enabled", external_access_enabled)
+        if external_access_recipients is not None:
+            pulumi.set(__self__, "external_access_recipients", external_access_recipients)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if use_case_ids is not None:
+            pulumi.set(__self__, "use_case_ids", use_case_ids)
+
+    @property
+    @pulumi.getter(name="environmentId")
+    def environment_id(self) -> pulumi.Input[str]:
+        """
+        The ID of the Execution Environment used to create the Custom Application.
+        """
+        return pulumi.get(self, "environment_id")
+
+    @environment_id.setter
+    def environment_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "environment_id", value)
+
+    @property
+    @pulumi.getter(name="externalAccessEnabled")
+    def external_access_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether external access is enabled for the Custom Application.
+        """
+        return pulumi.get(self, "external_access_enabled")
+
+    @external_access_enabled.setter
+    def external_access_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "external_access_enabled", value)
+
+    @property
+    @pulumi.getter(name="externalAccessRecipients")
+    def external_access_recipients(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of external email addresses that have access to the Custom Application.
+        """
+        return pulumi.get(self, "external_access_recipients")
+
+    @external_access_recipients.setter
+    def external_access_recipients(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "external_access_recipients", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the Custom Application.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="useCaseIds")
+    def use_case_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of Use Case IDs to add the Custom Application to.
+        """
+        return pulumi.get(self, "use_case_ids")
+
+    @use_case_ids.setter
+    def use_case_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "use_case_ids", value)
+
+
+@pulumi.input_type
+class _CustomApplicationFromEnvironmentState:
+    def __init__(__self__, *,
+                 application_url: Optional[pulumi.Input[str]] = None,
+                 environment_id: Optional[pulumi.Input[str]] = None,
+                 environment_version_id: Optional[pulumi.Input[str]] = None,
+                 external_access_enabled: Optional[pulumi.Input[bool]] = None,
+                 external_access_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 use_case_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Input properties used for looking up and filtering CustomApplicationFromEnvironment resources.
+        :param pulumi.Input[str] application_url: The URL of the Custom Application.
+        :param pulumi.Input[str] environment_id: The ID of the Execution Environment used to create the Custom Application.
+        :param pulumi.Input[str] environment_version_id: The version ID of the Execution Environment used to create the Custom Application.
+        :param pulumi.Input[bool] external_access_enabled: Whether external access is enabled for the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] external_access_recipients: The list of external email addresses that have access to the Custom Application.
+        :param pulumi.Input[str] name: The name of the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] use_case_ids: The list of Use Case IDs to add the Custom Application to.
+        """
+        if application_url is not None:
+            pulumi.set(__self__, "application_url", application_url)
+        if environment_id is not None:
+            pulumi.set(__self__, "environment_id", environment_id)
+        if environment_version_id is not None:
+            pulumi.set(__self__, "environment_version_id", environment_version_id)
+        if external_access_enabled is not None:
+            pulumi.set(__self__, "external_access_enabled", external_access_enabled)
+        if external_access_recipients is not None:
+            pulumi.set(__self__, "external_access_recipients", external_access_recipients)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if use_case_ids is not None:
+            pulumi.set(__self__, "use_case_ids", use_case_ids)
+
+    @property
+    @pulumi.getter(name="applicationUrl")
+    def application_url(self) -> Optional[pulumi.Input[str]]:
+        """
+        The URL of the Custom Application.
+        """
+        return pulumi.get(self, "application_url")
+
+    @application_url.setter
+    def application_url(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "application_url", value)
+
+    @property
+    @pulumi.getter(name="environmentId")
+    def environment_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of the Execution Environment used to create the Custom Application.
+        """
+        return pulumi.get(self, "environment_id")
+
+    @environment_id.setter
+    def environment_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "environment_id", value)
+
+    @property
+    @pulumi.getter(name="environmentVersionId")
+    def environment_version_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The version ID of the Execution Environment used to create the Custom Application.
+        """
+        return pulumi.get(self, "environment_version_id")
+
+    @environment_version_id.setter
+    def environment_version_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "environment_version_id", value)
+
+    @property
+    @pulumi.getter(name="externalAccessEnabled")
+    def external_access_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether external access is enabled for the Custom Application.
+        """
+        return pulumi.get(self, "external_access_enabled")
+
+    @external_access_enabled.setter
+    def external_access_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "external_access_enabled", value)
+
+    @property
+    @pulumi.getter(name="externalAccessRecipients")
+    def external_access_recipients(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of external email addresses that have access to the Custom Application.
+        """
+        return pulumi.get(self, "external_access_recipients")
+
+    @external_access_recipients.setter
+    def external_access_recipients(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "external_access_recipients", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the Custom Application.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="useCaseIds")
+    def use_case_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of Use Case IDs to add the Custom Application to.
+        """
+        return pulumi.get(self, "use_case_ids")
+
+    @use_case_ids.setter
+    def use_case_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "use_case_ids", value)
+
+
+class CustomApplicationFromEnvironment(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 environment_id: Optional[pulumi.Input[str]] = None,
+                 external_access_enabled: Optional[pulumi.Input[bool]] = None,
+                 external_access_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 use_case_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 __props__=None):
+        """
+        Custom Application created from an Execution Environment.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_datarobot as datarobot
+
+        example = datarobot.CustomApplicationFromEnvironment("example",
+            environment_id="6542cd582a9d3d51bf4ac71e",
+            external_access_enabled=True,
+            external_access_recipients=["recipient@example.com"])
+        pulumi.export("datarobotCustomApplicationId", example.id)
+        pulumi.export("datarobotCustomApplicationUrl", example.application_url)
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] environment_id: The ID of the Execution Environment used to create the Custom Application.
+        :param pulumi.Input[bool] external_access_enabled: Whether external access is enabled for the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] external_access_recipients: The list of external email addresses that have access to the Custom Application.
+        :param pulumi.Input[str] name: The name of the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] use_case_ids: The list of Use Case IDs to add the Custom Application to.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: CustomApplicationFromEnvironmentArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Custom Application created from an Execution Environment.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_datarobot as datarobot
+
+        example = datarobot.CustomApplicationFromEnvironment("example",
+            environment_id="6542cd582a9d3d51bf4ac71e",
+            external_access_enabled=True,
+            external_access_recipients=["recipient@example.com"])
+        pulumi.export("datarobotCustomApplicationId", example.id)
+        pulumi.export("datarobotCustomApplicationUrl", example.application_url)
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param CustomApplicationFromEnvironmentArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(CustomApplicationFromEnvironmentArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 environment_id: Optional[pulumi.Input[str]] = None,
+                 external_access_enabled: Optional[pulumi.Input[bool]] = None,
+                 external_access_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 use_case_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = CustomApplicationFromEnvironmentArgs.__new__(CustomApplicationFromEnvironmentArgs)
+
+            if environment_id is None and not opts.urn:
+                raise TypeError("Missing required property 'environment_id'")
+            __props__.__dict__["environment_id"] = environment_id
+            __props__.__dict__["external_access_enabled"] = external_access_enabled
+            __props__.__dict__["external_access_recipients"] = external_access_recipients
+            __props__.__dict__["name"] = name
+            __props__.__dict__["use_case_ids"] = use_case_ids
+            __props__.__dict__["application_url"] = None
+            __props__.__dict__["environment_version_id"] = None
+        super(CustomApplicationFromEnvironment, __self__).__init__(
+            'datarobot:index/customApplicationFromEnvironment:CustomApplicationFromEnvironment',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            application_url: Optional[pulumi.Input[str]] = None,
+            environment_id: Optional[pulumi.Input[str]] = None,
+            environment_version_id: Optional[pulumi.Input[str]] = None,
+            external_access_enabled: Optional[pulumi.Input[bool]] = None,
+            external_access_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+            name: Optional[pulumi.Input[str]] = None,
+            use_case_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'CustomApplicationFromEnvironment':
+        """
+        Get an existing CustomApplicationFromEnvironment resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] application_url: The URL of the Custom Application.
+        :param pulumi.Input[str] environment_id: The ID of the Execution Environment used to create the Custom Application.
+        :param pulumi.Input[str] environment_version_id: The version ID of the Execution Environment used to create the Custom Application.
+        :param pulumi.Input[bool] external_access_enabled: Whether external access is enabled for the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] external_access_recipients: The list of external email addresses that have access to the Custom Application.
+        :param pulumi.Input[str] name: The name of the Custom Application.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] use_case_ids: The list of Use Case IDs to add the Custom Application to.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _CustomApplicationFromEnvironmentState.__new__(_CustomApplicationFromEnvironmentState)
+
+        __props__.__dict__["application_url"] = application_url
+        __props__.__dict__["environment_id"] = environment_id
+        __props__.__dict__["environment_version_id"] = environment_version_id
+        __props__.__dict__["external_access_enabled"] = external_access_enabled
+        __props__.__dict__["external_access_recipients"] = external_access_recipients
+        __props__.__dict__["name"] = name
+        __props__.__dict__["use_case_ids"] = use_case_ids
+        return CustomApplicationFromEnvironment(resource_name, opts=opts, __props__=__props__)
+
+    @property
+    @pulumi.getter(name="applicationUrl")
+    def application_url(self) -> pulumi.Output[str]:
+        """
+        The URL of the Custom Application.
+        """
+        return pulumi.get(self, "application_url")
+
+    @property
+    @pulumi.getter(name="environmentId")
+    def environment_id(self) -> pulumi.Output[str]:
+        """
+        The ID of the Execution Environment used to create the Custom Application.
+        """
+        return pulumi.get(self, "environment_id")
+
+    @property
+    @pulumi.getter(name="environmentVersionId")
+    def environment_version_id(self) -> pulumi.Output[str]:
+        """
+        The version ID of the Execution Environment used to create the Custom Application.
+        """
+        return pulumi.get(self, "environment_version_id")
+
+    @property
+    @pulumi.getter(name="externalAccessEnabled")
+    def external_access_enabled(self) -> pulumi.Output[bool]:
+        """
+        Whether external access is enabled for the Custom Application.
+        """
+        return pulumi.get(self, "external_access_enabled")
+
+    @property
+    @pulumi.getter(name="externalAccessRecipients")
+    def external_access_recipients(self) -> pulumi.Output[Optional[Sequence[str]]]:
+        """
+        The list of external email addresses that have access to the Custom Application.
+        """
+        return pulumi.get(self, "external_access_recipients")
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Output[str]:
+        """
+        The name of the Custom Application.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="useCaseIds")
+    def use_case_ids(self) -> pulumi.Output[Optional[Sequence[str]]]:
+        """
+        The list of Use Case IDs to add the Custom Application to.
+        """
+        return pulumi.get(self, "use_case_ids")
+

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/pulumi_datarobot/execution_environment.py

@@ -19,43 +19,36 @@ __all__ = ['ExecutionEnvironmentArgs', 'ExecutionEnvironment']
 @pulumi.input_type
 class ExecutionEnvironmentArgs:
     def __init__(__self__, *,
-                 docker_context_path: pulumi.Input[str],
                  programming_language: pulumi.Input[str],
                  use_cases: pulumi.Input[Sequence[pulumi.Input[str]]],
                  description: Optional[pulumi.Input[str]] = None,
+                 docker_context_path: Optional[pulumi.Input[str]] = None,
+                 docker_image: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  version_description: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a ExecutionEnvironment resource.
-        :param pulumi.Input[str] docker_context_path: The path to a docker context archive or folder
         :param pulumi.Input[str] programming_language: The programming language of the Execution Environment.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] use_cases: The list of Use Cases that the Execution Environment supports.
         :param pulumi.Input[str] description: The description of the Execution Environment.
+        :param pulumi.Input[str] docker_context_path: The path to a docker context archive or folder
+        :param pulumi.Input[str] docker_image: A prebuilt environment image saved as a tarball using the Docker save command.
         :param pulumi.Input[str] name: The name of the Execution Environment.
         :param pulumi.Input[str] version_description: The description of the Execution Environment version.
         """
-        pulumi.set(__self__, "docker_context_path", docker_context_path)
         pulumi.set(__self__, "programming_language", programming_language)
         pulumi.set(__self__, "use_cases", use_cases)
         if description is not None:
             pulumi.set(__self__, "description", description)
+        if docker_context_path is not None:
+            pulumi.set(__self__, "docker_context_path", docker_context_path)
+        if docker_image is not None:
+            pulumi.set(__self__, "docker_image", docker_image)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if version_description is not None:
             pulumi.set(__self__, "version_description", version_description)
 
-    @property
-    @pulumi.getter(name="dockerContextPath")
-    def docker_context_path(self) -> pulumi.Input[str]:
-        """
-        The path to a docker context archive or folder
-        """
-        return pulumi.get(self, "docker_context_path")
-
-    @docker_context_path.setter
-    def docker_context_path(self, value: pulumi.Input[str]):
-        pulumi.set(self, "docker_context_path", value)
-
     @property
     @pulumi.getter(name="programmingLanguage")
     def programming_language(self) -> pulumi.Input[str]:
@@ -92,6 +85,30 @@ class ExecutionEnvironmentArgs:
     def description(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "description", value)
 
+    @property
+    @pulumi.getter(name="dockerContextPath")
+    def docker_context_path(self) -> Optional[pulumi.Input[str]]:
+        """
+        The path to a docker context archive or folder
+        """
+        return pulumi.get(self, "docker_context_path")
+
+    @docker_context_path.setter
+    def docker_context_path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "docker_context_path", value)
+
+    @property
+    @pulumi.getter(name="dockerImage")
+    def docker_image(self) -> Optional[pulumi.Input[str]]:
+        """
+        A prebuilt environment image saved as a tarball using the Docker save command.
+        """
+        return pulumi.get(self, "docker_image")
+
+    @docker_image.setter
+    def docker_image(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "docker_image", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
@@ -123,6 +140,7 @@ class _ExecutionEnvironmentState:
                  build_status: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  docker_context_path: Optional[pulumi.Input[str]] = None,
+                 docker_image: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  programming_language: Optional[pulumi.Input[str]] = None,
                  use_cases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -133,6 +151,7 @@ class _ExecutionEnvironmentState:
         :param pulumi.Input[str] build_status: The status of the Execution Environment version build.
         :param pulumi.Input[str] description: The description of the Execution Environment.
         :param pulumi.Input[str] docker_context_path: The path to a docker context archive or folder
+        :param pulumi.Input[str] docker_image: A prebuilt environment image saved as a tarball using the Docker save command.
         :param pulumi.Input[str] name: The name of the Execution Environment.
         :param pulumi.Input[str] programming_language: The programming language of the Execution Environment.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] use_cases: The list of Use Cases that the Execution Environment supports.
@@ -145,6 +164,8 @@ class _ExecutionEnvironmentState:
             pulumi.set(__self__, "description", description)
         if docker_context_path is not None:
             pulumi.set(__self__, "docker_context_path", docker_context_path)
+        if docker_image is not None:
+            pulumi.set(__self__, "docker_image", docker_image)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if programming_language is not None:
@@ -192,6 +213,18 @@ class _ExecutionEnvironmentState:
     def docker_context_path(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "docker_context_path", value)
 
+    @property
+    @pulumi.getter(name="dockerImage")
+    def docker_image(self) -> Optional[pulumi.Input[str]]:
+        """
+        A prebuilt environment image saved as a tarball using the Docker save command.
+        """
+        return pulumi.get(self, "docker_image")
+
+    @docker_image.setter
+    def docker_image(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "docker_image", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
@@ -260,6 +293,7 @@ class ExecutionEnvironment(pulumi.CustomResource):
                  opts: Optional[pulumi.ResourceOptions] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  docker_context_path: Optional[pulumi.Input[str]] = None,
+                 docker_image: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  programming_language: Optional[pulumi.Input[str]] = None,
                  use_cases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -275,16 +309,20 @@ class ExecutionEnvironment(pulumi.CustomResource):
         import pulumi_datarobot as datarobot
 
         example = datarobot.ExecutionEnvironment("example",
+            programming_language="python",
             description="Example Execution Environment Description",
             docker_context_path="docker_context.zip",
-            programming_language="python",
+            docker_image="docker_image.tar",
             use_cases=["customModel"])
+        pulumi.export("datarobotExecutionEnvironmentId", example.id)
+        pulumi.export("datarobotExecutionEnvironmentVersionId", example.version_id)
         ```
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[str] description: The description of the Execution Environment.
         :param pulumi.Input[str] docker_context_path: The path to a docker context archive or folder
+        :param pulumi.Input[str] docker_image: A prebuilt environment image saved as a tarball using the Docker save command.
         :param pulumi.Input[str] name: The name of the Execution Environment.
         :param pulumi.Input[str] programming_language: The programming language of the Execution Environment.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] use_cases: The list of Use Cases that the Execution Environment supports.
@@ -306,10 +344,13 @@ class ExecutionEnvironment(pulumi.CustomResource):
         import pulumi_datarobot as datarobot
 
         example = datarobot.ExecutionEnvironment("example",
+            programming_language="python",
             description="Example Execution Environment Description",
             docker_context_path="docker_context.zip",
-            programming_language="python",
+            docker_image="docker_image.tar",
             use_cases=["customModel"])
+        pulumi.export("datarobotExecutionEnvironmentId", example.id)
+        pulumi.export("datarobotExecutionEnvironmentVersionId", example.version_id)
         ```
 
         :param str resource_name: The name of the resource.
@@ -329,6 +370,7 @@ class ExecutionEnvironment(pulumi.CustomResource):
                  opts: Optional[pulumi.ResourceOptions] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  docker_context_path: Optional[pulumi.Input[str]] = None,
+                 docker_image: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  programming_language: Optional[pulumi.Input[str]] = None,
                  use_cases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -343,9 +385,8 @@ class ExecutionEnvironment(pulumi.CustomResource):
             __props__ = ExecutionEnvironmentArgs.__new__(ExecutionEnvironmentArgs)
 
             __props__.__dict__["description"] = description
-            if docker_context_path is None and not opts.urn:
-                raise TypeError("Missing required property 'docker_context_path'")
             __props__.__dict__["docker_context_path"] = docker_context_path
+            __props__.__dict__["docker_image"] = docker_image
             __props__.__dict__["name"] = name
             if programming_language is None and not opts.urn:
                 raise TypeError("Missing required property 'programming_language'")
@@ -369,6 +410,7 @@ class ExecutionEnvironment(pulumi.CustomResource):
             build_status: Optional[pulumi.Input[str]] = None,
             description: Optional[pulumi.Input[str]] = None,
             docker_context_path: Optional[pulumi.Input[str]] = None,
+            docker_image: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
             programming_language: Optional[pulumi.Input[str]] = None,
             use_cases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -384,6 +426,7 @@ class ExecutionEnvironment(pulumi.CustomResource):
         :param pulumi.Input[str] build_status: The status of the Execution Environment version build.
         :param pulumi.Input[str] description: The description of the Execution Environment.
         :param pulumi.Input[str] docker_context_path: The path to a docker context archive or folder
+        :param pulumi.Input[str] docker_image: A prebuilt environment image saved as a tarball using the Docker save command.
         :param pulumi.Input[str] name: The name of the Execution Environment.
         :param pulumi.Input[str] programming_language: The programming language of the Execution Environment.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] use_cases: The list of Use Cases that the Execution Environment supports.
@@ -397,6 +440,7 @@ class ExecutionEnvironment(pulumi.CustomResource):
         __props__.__dict__["build_status"] = build_status
         __props__.__dict__["description"] = description
         __props__.__dict__["docker_context_path"] = docker_context_path
+        __props__.__dict__["docker_image"] = docker_image
         __props__.__dict__["name"] = name
         __props__.__dict__["programming_language"] = programming_language
         __props__.__dict__["use_cases"] = use_cases
@@ -422,12 +466,20 @@ class ExecutionEnvironment(pulumi.CustomResource):
 
     @property
     @pulumi.getter(name="dockerContextPath")
-    def docker_context_path(self) -> pulumi.Output[str]:
+    def docker_context_path(self) -> pulumi.Output[Optional[str]]:
         """
         The path to a docker context archive or folder
         """
         return pulumi.get(self, "docker_context_path")
 
+    @property
+    @pulumi.getter(name="dockerImage")
+    def docker_image(self) -> pulumi.Output[Optional[str]]:
+        """
+        A prebuilt environment image saved as a tarball using the Docker save command.
+        """
+        return pulumi.get(self, "docker_image")
+
     @property
     @pulumi.getter
     def name(self) -> pulumi.Output[str]:

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/pulumi_datarobot/outputs.py

@@ -16,6 +16,7 @@ from . import _utilities
 from . import outputs
 
 __all__ = [
+    'ApplicationSourceResources',
     'ApplicationSourceRuntimeParameterValue',
     'BatchPredictionJobDefinitionCsvSettings',
     'BatchPredictionJobDefinitionIntakeSettings',
@@ -71,6 +72,68 @@ __all__ = [
     'VectorDatabaseChunkingParameters',
 ]
 
+@pulumi.output_type
+class ApplicationSourceResources(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "resourceLabel":
+            suggest = "resource_label"
+        elif key == "sessionAffinity":
+            suggest = "session_affinity"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ApplicationSourceResources. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ApplicationSourceResources.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ApplicationSourceResources.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 replicas: Optional[int] = None,
+                 resource_label: Optional[str] = None,
+                 session_affinity: Optional[bool] = None):
+        """
+        :param int replicas: The replicas for the Application Source.
+        :param str resource_label: The resource label for the Application Source.
+        :param bool session_affinity: The session affinity for the Application Source.
+        """
+        if replicas is not None:
+            pulumi.set(__self__, "replicas", replicas)
+        if resource_label is not None:
+            pulumi.set(__self__, "resource_label", resource_label)
+        if session_affinity is not None:
+            pulumi.set(__self__, "session_affinity", session_affinity)
+
+    @property
+    @pulumi.getter
+    def replicas(self) -> Optional[int]:
+        """
+        The replicas for the Application Source.
+        """
+        return pulumi.get(self, "replicas")
+
+    @property
+    @pulumi.getter(name="resourceLabel")
+    def resource_label(self) -> Optional[str]:
+        """
+        The resource label for the Application Source.
+        """
+        return pulumi.get(self, "resource_label")
+
+    @property
+    @pulumi.getter(name="sessionAffinity")
+    def session_affinity(self) -> Optional[bool]:
+        """
+        The session affinity for the Application Source.
+        """
+        return pulumi.get(self, "session_affinity")
+
+
 @pulumi.output_type
 class ApplicationSourceRuntimeParameterValue(dict):
     def __init__(__self__, *,

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/pulumi_datarobot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi-datarobot
-Version: 0.5.4
+Version: 0.7.2
 Summary: A Pulumi package for creating and managing DataRobot resources.
 Home-page: https://www.datarobot.com
 License: Apache-2.0

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/pulumi_datarobot.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ pulumi_datarobot/aws_credential.py
 pulumi_datarobot/basic_credential.py
 pulumi_datarobot/batch_prediction_job_definition.py
 pulumi_datarobot/custom_application.py
+pulumi_datarobot/custom_application_from_environment.py
 pulumi_datarobot/custom_job.py
 pulumi_datarobot/custom_metric_from_job.py
 pulumi_datarobot/custom_metric_job.py

{pulumi_datarobot-0.5.4 → pulumi_datarobot-0.7.2}/setup.py

@@ -8,7 +8,7 @@ from setuptools.command.install import install
 from subprocess import check_call
 
 
-VERSION = "0.5.4"
+VERSION = "0.7.2"
 def readme():
     try:
         with open('README.md', encoding='utf-8') as f: