pulumi-datarobot 0.1.31__tar.gz → 0.1.33__tar.gz

pulumi_datarobot-0.1.33/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: pulumi_datarobot
+Version: 0.1.33
+Summary: A Pulumi package for creating and managing DataRobot resources.
+Home-page: https://www.datarobot.com
+License: Apache-2.0
+Project-URL: Repository, https://github.com/datarobot-community/pulumi-datarobot
+Keywords: datarobot ai category/cloud
+Platform: UNKNOWN
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# DataRobot Resource Provider
+
+The DataRobot Resource Provider lets you manage [DataRobot](https://www.datarobot.com/) resources.
+The provider is built on [terraform-provider-datarobot](https://github.com/datarobot-community/terraform-provider-datarobot).
+To use this package, please install the [Pulumi CLI](https://pulumi.io/) first.
+
+## Installing
+
+This package is available for several languages/platforms:
+
+### Python
+
+To use from Python, install using `pip`:
+
+```bash
+pip install pulumi_datarobot
+```
+
+### Javscript/Typescript
+
+To use from JavaScript or TypeScript in Node.js, install using either `npm`:
+
+```bash
+npm install @datarobot/pulumi-datarobot
+```
+
+or `yarn`:
+
+```bash
+yarn add @datarobot/pulumi-datarobot
+```
+
+### Go
+
+Coming soon...
+
+### .NET
+
+Coming soon...
+
+### YAML
+
+No install necessary, just run `pulumi up`.
+
+## Configuration
+
+The following configuration points are available for the DataRobot provider:
+
+- `datarobot:apikey` (environment: `DATAROBOT_API_KEY`) - the API key for DataRobot
+- `datarobot:endpoint` (environment: `DATAROBOT_ENDPOINT`) - the endpoint for DataRobot
+
+## Examples
+
+See [datarobot-pulumi examples](https://github.com/datarobot-community/pulumi-datarobot/tree/main/examples)
+
+

pulumi_datarobot-0.1.33/README.md

@@ -0,0 +1,54 @@
+# DataRobot Resource Provider
+
+The DataRobot Resource Provider lets you manage [DataRobot](https://www.datarobot.com/) resources.
+The provider is built on [terraform-provider-datarobot](https://github.com/datarobot-community/terraform-provider-datarobot).
+To use this package, please install the [Pulumi CLI](https://pulumi.io/) first.
+
+## Installing
+
+This package is available for several languages/platforms:
+
+### Python
+
+To use from Python, install using `pip`:
+
+```bash
+pip install pulumi_datarobot
+```
+
+### Javscript/Typescript
+
+To use from JavaScript or TypeScript in Node.js, install using either `npm`:
+
+```bash
+npm install @datarobot/pulumi-datarobot
+```
+
+or `yarn`:
+
+```bash
+yarn add @datarobot/pulumi-datarobot
+```
+
+### Go
+
+Coming soon...
+
+### .NET
+
+Coming soon...
+
+### YAML
+
+No install necessary, just run `pulumi up`.
+
+## Configuration
+
+The following configuration points are available for the DataRobot provider:
+
+- `datarobot:apikey` (environment: `DATAROBOT_API_KEY`) - the API key for DataRobot
+- `datarobot:endpoint` (environment: `DATAROBOT_ENDPOINT`) - the endpoint for DataRobot
+
+## Examples
+
+See [datarobot-pulumi examples](https://github.com/datarobot-community/pulumi-datarobot/tree/main/examples)

{pulumi_datarobot-0.1.31 → pulumi_datarobot-0.1.33}/pulumi_datarobot/_inputs.py

@@ -22,6 +22,8 @@ __all__ = [
     'DeploymentSettingsArgs',
     'DeploymentSettingsAssociationIdArgs',
     'DeploymentSettingsPredictionsSettingsArgs',
+    'LlmBlueprintLlmSettingsArgs',
+    'LlmBlueprintVectorDatabaseSettingsArgs',
     'VectorDatabaseChunkingParametersArgs',
 ]
 
@@ -109,6 +111,10 @@ class CustomModelGuardConfigurationArgs:
                  template_name: pulumi.Input[str],
                  deployment_id: Optional[pulumi.Input[str]] = None,
                  input_column_name: Optional[pulumi.Input[str]] = None,
+                 llm_type: Optional[pulumi.Input[str]] = None,
+                 openai_api_base: Optional[pulumi.Input[str]] = None,
+                 openai_credential: Optional[pulumi.Input[str]] = None,
+                 openai_deployment_id: Optional[pulumi.Input[str]] = None,
                  output_column_name: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input['CustomModelGuardConfigurationInterventionArgs'] intervention: The intervention for the guard configuration.
@@ -117,6 +123,10 @@ class CustomModelGuardConfigurationArgs:
         :param pulumi.Input[str] template_name: The template name of the guard configuration.
         :param pulumi.Input[str] deployment_id: The deployment ID of this guard.
         :param pulumi.Input[str] input_column_name: The input column name of this guard.
+        :param pulumi.Input[str] llm_type: The LLM type for this guard.
+        :param pulumi.Input[str] openai_api_base: The OpenAI API base URL for this guard.
+        :param pulumi.Input[str] openai_credential: The ID of an OpenAI credential for this guard.
+        :param pulumi.Input[str] openai_deployment_id: The ID of an OpenAI deployment for this guard.
         :param pulumi.Input[str] output_column_name: The output column name of this guard.
         """
         pulumi.set(__self__, "intervention", intervention)
@@ -127,6 +137,14 @@ class CustomModelGuardConfigurationArgs:
             pulumi.set(__self__, "deployment_id", deployment_id)
         if input_column_name is not None:
             pulumi.set(__self__, "input_column_name", input_column_name)
+        if llm_type is not None:
+            pulumi.set(__self__, "llm_type", llm_type)
+        if openai_api_base is not None:
+            pulumi.set(__self__, "openai_api_base", openai_api_base)
+        if openai_credential is not None:
+            pulumi.set(__self__, "openai_credential", openai_credential)
+        if openai_deployment_id is not None:
+            pulumi.set(__self__, "openai_deployment_id", openai_deployment_id)
         if output_column_name is not None:
             pulumi.set(__self__, "output_column_name", output_column_name)
 
@@ -202,6 +220,54 @@ class CustomModelGuardConfigurationArgs:
     def input_column_name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "input_column_name", value)
 
+    @property
+    @pulumi.getter(name="llmType")
+    def llm_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        The LLM type for this guard.
+        """
+        return pulumi.get(self, "llm_type")
+
+    @llm_type.setter
+    def llm_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "llm_type", value)
+
+    @property
+    @pulumi.getter(name="openaiApiBase")
+    def openai_api_base(self) -> Optional[pulumi.Input[str]]:
+        """
+        The OpenAI API base URL for this guard.
+        """
+        return pulumi.get(self, "openai_api_base")
+
+    @openai_api_base.setter
+    def openai_api_base(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "openai_api_base", value)
+
+    @property
+    @pulumi.getter(name="openaiCredential")
+    def openai_credential(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of an OpenAI credential for this guard.
+        """
+        return pulumi.get(self, "openai_credential")
+
+    @openai_credential.setter
+    def openai_credential(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "openai_credential", value)
+
+    @property
+    @pulumi.getter(name="openaiDeploymentId")
+    def openai_deployment_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of an OpenAI deployment for this guard.
+        """
+        return pulumi.get(self, "openai_deployment_id")
+
+    @openai_deployment_id.setter
+    def openai_deployment_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "openai_deployment_id", value)
+
     @property
     @pulumi.getter(name="outputColumnName")
     def output_column_name(self) -> Optional[pulumi.Input[str]]:
@@ -578,13 +644,16 @@ class DeploymentSettingsArgs:
 class DeploymentSettingsAssociationIdArgs:
     def __init__(__self__, *,
                  auto_generate_id: pulumi.Input[bool],
-                 feature_name: pulumi.Input[str]):
+                 feature_name: pulumi.Input[str],
+                 required_in_prediction_requests: pulumi.Input[bool]):
         """
         :param pulumi.Input[bool] auto_generate_id: Whether to automatically generate an association ID.
         :param pulumi.Input[str] feature_name: The name of the feature to use as the association ID.
+        :param pulumi.Input[bool] required_in_prediction_requests: Whether the association ID is required in prediction requests.
         """
         pulumi.set(__self__, "auto_generate_id", auto_generate_id)
         pulumi.set(__self__, "feature_name", feature_name)
+        pulumi.set(__self__, "required_in_prediction_requests", required_in_prediction_requests)
 
     @property
     @pulumi.getter(name="autoGenerateId")
@@ -610,6 +679,18 @@ class DeploymentSettingsAssociationIdArgs:
     def feature_name(self, value: pulumi.Input[str]):
         pulumi.set(self, "feature_name", value)
 
+    @property
+    @pulumi.getter(name="requiredInPredictionRequests")
+    def required_in_prediction_requests(self) -> pulumi.Input[bool]:
+        """
+        Whether the association ID is required in prediction requests.
+        """
+        return pulumi.get(self, "required_in_prediction_requests")
+
+    @required_in_prediction_requests.setter
+    def required_in_prediction_requests(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "required_in_prediction_requests", value)
+
 
 @pulumi.input_type
 class DeploymentSettingsPredictionsSettingsArgs:
@@ -663,6 +744,116 @@ class DeploymentSettingsPredictionsSettingsArgs:
         pulumi.set(self, "real_time", value)
 
 
+@pulumi.input_type
+class LlmBlueprintLlmSettingsArgs:
+    def __init__(__self__, *,
+                 max_completion_length: Optional[pulumi.Input[int]] = None,
+                 system_prompt: Optional[pulumi.Input[str]] = None,
+                 temperature: Optional[pulumi.Input[float]] = None,
+                 top_p: Optional[pulumi.Input[float]] = None):
+        """
+        :param pulumi.Input[int] max_completion_length: The maximum number of tokens allowed in the completion. The combined count of this value and prompt tokens must be below the model's maximum context size, where prompt token count is comprised of system prompt, user prompt, recent chat history, and vector database citations.
+        :param pulumi.Input[str] system_prompt: Guides the style of the LLM response. It is a 'universal' prompt, prepended to all individual prompts.
+        :param pulumi.Input[float] temperature: Controls the randomness of model output, where higher values return more diverse output and lower values return more deterministic results.
+        :param pulumi.Input[float] top_p: Threshold that controls the selection of words included in the response, based on a cumulative probability cutoff for token selection. Higher numbers return more diverse options for outputs.
+        """
+        if max_completion_length is not None:
+            pulumi.set(__self__, "max_completion_length", max_completion_length)
+        if system_prompt is not None:
+            pulumi.set(__self__, "system_prompt", system_prompt)
+        if temperature is not None:
+            pulumi.set(__self__, "temperature", temperature)
+        if top_p is not None:
+            pulumi.set(__self__, "top_p", top_p)
+
+    @property
+    @pulumi.getter(name="maxCompletionLength")
+    def max_completion_length(self) -> Optional[pulumi.Input[int]]:
+        """
+        The maximum number of tokens allowed in the completion. The combined count of this value and prompt tokens must be below the model's maximum context size, where prompt token count is comprised of system prompt, user prompt, recent chat history, and vector database citations.
+        """
+        return pulumi.get(self, "max_completion_length")
+
+    @max_completion_length.setter
+    def max_completion_length(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_completion_length", value)
+
+    @property
+    @pulumi.getter(name="systemPrompt")
+    def system_prompt(self) -> Optional[pulumi.Input[str]]:
+        """
+        Guides the style of the LLM response. It is a 'universal' prompt, prepended to all individual prompts.
+        """
+        return pulumi.get(self, "system_prompt")
+
+    @system_prompt.setter
+    def system_prompt(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "system_prompt", value)
+
+    @property
+    @pulumi.getter
+    def temperature(self) -> Optional[pulumi.Input[float]]:
+        """
+        Controls the randomness of model output, where higher values return more diverse output and lower values return more deterministic results.
+        """
+        return pulumi.get(self, "temperature")
+
+    @temperature.setter
+    def temperature(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "temperature", value)
+
+    @property
+    @pulumi.getter(name="topP")
+    def top_p(self) -> Optional[pulumi.Input[float]]:
+        """
+        Threshold that controls the selection of words included in the response, based on a cumulative probability cutoff for token selection. Higher numbers return more diverse options for outputs.
+        """
+        return pulumi.get(self, "top_p")
+
+    @top_p.setter
+    def top_p(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "top_p", value)
+
+
+@pulumi.input_type
+class LlmBlueprintVectorDatabaseSettingsArgs:
+    def __init__(__self__, *,
+                 max_documents_retrieved_per_prompt: Optional[pulumi.Input[int]] = None,
+                 max_tokens: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] max_documents_retrieved_per_prompt: The maximum number of documents to retrieve from the Vector Database.
+        :param pulumi.Input[int] max_tokens: The maximum number of tokens to retrieve from the Vector Database.
+        """
+        if max_documents_retrieved_per_prompt is not None:
+            pulumi.set(__self__, "max_documents_retrieved_per_prompt", max_documents_retrieved_per_prompt)
+        if max_tokens is not None:
+            pulumi.set(__self__, "max_tokens", max_tokens)
+
+    @property
+    @pulumi.getter(name="maxDocumentsRetrievedPerPrompt")
+    def max_documents_retrieved_per_prompt(self) -> Optional[pulumi.Input[int]]:
+        """
+        The maximum number of documents to retrieve from the Vector Database.
+        """
+        return pulumi.get(self, "max_documents_retrieved_per_prompt")
+
+    @max_documents_retrieved_per_prompt.setter
+    def max_documents_retrieved_per_prompt(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_documents_retrieved_per_prompt", value)
+
+    @property
+    @pulumi.getter(name="maxTokens")
+    def max_tokens(self) -> Optional[pulumi.Input[int]]:
+        """
+        The maximum number of tokens to retrieve from the Vector Database.
+        """
+        return pulumi.get(self, "max_tokens")
+
+    @max_tokens.setter
+    def max_tokens(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_tokens", value)
+
+
 @pulumi.input_type
 class VectorDatabaseChunkingParametersArgs:
     def __init__(__self__, *,

{pulumi_datarobot-0.1.31 → pulumi_datarobot-0.1.33}/pulumi_datarobot/application_source.py

@@ -16,18 +16,23 @@ __all__ = ['ApplicationSourceArgs', 'ApplicationSource']
 @pulumi.input_type
 class ApplicationSourceArgs:
     def __init__(__self__, *,
-                 local_files: pulumi.Input[Sequence[pulumi.Input[str]]],
+                 files: Optional[Any] = None,
+                 folder_path: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  resource_settings: Optional[pulumi.Input['ApplicationSourceResourceSettingsArgs']] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSourceRuntimeParameterValueArgs']]]] = None):
         """
         The set of arguments for constructing a ApplicationSource resource.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] local_files: The list of local file paths used to build the Application Source.
+        :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['ApplicationSourceResourceSettingsArgs'] resource_settings: The resource settings for the Application Source.
         :param pulumi.Input[Sequence[pulumi.Input['ApplicationSourceRuntimeParameterValueArgs']]] runtime_parameter_values: The runtime parameter values for the Application Source.
         """
-        pulumi.set(__self__, "local_files", local_files)
+        if files is not None:
+            pulumi.set(__self__, "files", files)
+        if folder_path is not None:
+            pulumi.set(__self__, "folder_path", folder_path)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if resource_settings is not None:
@@ -36,16 +41,28 @@ class ApplicationSourceArgs:
             pulumi.set(__self__, "runtime_parameter_values", runtime_parameter_values)
 
     @property
-    @pulumi.getter(name="localFiles")
-    def local_files(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+    @pulumi.getter
+    def files(self) -> Optional[Any]:
         """
-        The list of local file paths used to build the Application Source.
+        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.
         """
-        return pulumi.get(self, "local_files")
+        return pulumi.get(self, "files")
 
-    @local_files.setter
-    def local_files(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
-        pulumi.set(self, "local_files", value)
+    @files.setter
+    def files(self, value: Optional[Any]):
+        pulumi.set(self, "files", value)
+
+    @property
+    @pulumi.getter(name="folderPath")
+    def folder_path(self) -> Optional[pulumi.Input[str]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "folder_path")
+
+    @folder_path.setter
+    def folder_path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "folder_path", value)
 
     @property
     @pulumi.getter
@@ -87,21 +104,25 @@ class ApplicationSourceArgs:
 @pulumi.input_type
 class _ApplicationSourceState:
     def __init__(__self__, *,
-                 local_files: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 files: Optional[Any] = None,
+                 folder_path: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  resource_settings: Optional[pulumi.Input['ApplicationSourceResourceSettingsArgs']] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSourceRuntimeParameterValueArgs']]]] = None,
                  version_id: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering ApplicationSource resources.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] local_files: The list of local file paths used to build the Application Source.
+        :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['ApplicationSourceResourceSettingsArgs'] resource_settings: The resource settings 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.
         """
-        if local_files is not None:
-            pulumi.set(__self__, "local_files", local_files)
+        if files is not None:
+            pulumi.set(__self__, "files", files)
+        if folder_path is not None:
+            pulumi.set(__self__, "folder_path", folder_path)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if resource_settings is not None:
@@ -112,16 +133,28 @@ class _ApplicationSourceState:
             pulumi.set(__self__, "version_id", version_id)
 
     @property
-    @pulumi.getter(name="localFiles")
-    def local_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+    @pulumi.getter
+    def files(self) -> Optional[Any]:
         """
-        The list of local file paths used to build the Application Source.
+        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.
         """
-        return pulumi.get(self, "local_files")
+        return pulumi.get(self, "files")
 
-    @local_files.setter
-    def local_files(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "local_files", value)
+    @files.setter
+    def files(self, value: Optional[Any]):
+        pulumi.set(self, "files", value)
+
+    @property
+    @pulumi.getter(name="folderPath")
+    def folder_path(self) -> Optional[pulumi.Input[str]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "folder_path")
+
+    @folder_path.setter
+    def folder_path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "folder_path", value)
 
     @property
     @pulumi.getter
@@ -177,7 +210,8 @@ class ApplicationSource(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 local_files: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 files: Optional[Any] = None,
+                 folder_path: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  resource_settings: Optional[pulumi.Input[Union['ApplicationSourceResourceSettingsArgs', 'ApplicationSourceResourceSettingsArgsDict']]] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]]] = None,
@@ -191,9 +225,9 @@ class ApplicationSource(pulumi.CustomResource):
         import pulumi
         import pulumi_datarobot as datarobot
 
-        example = datarobot.ApplicationSource("example", local_files=[
-            "start-app.sh",
-            "streamlit-app.py",
+        example = datarobot.ApplicationSource("example", files=[
+            ["start-app.sh"],
+            ["streamlit-app.py"],
         ])
         pulumi.export("datarobotApplicationSourceId", example.id)
         pulumi.export("datarobotApplicationSourceVersionId", example.version_id)
@@ -201,7 +235,8 @@ class ApplicationSource(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] local_files: The list of local file paths used to build the Application Source.
+        :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[Union['ApplicationSourceResourceSettingsArgs', 'ApplicationSourceResourceSettingsArgsDict']] resource_settings: The resource settings for the Application Source.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]] runtime_parameter_values: The runtime parameter values for the Application Source.
@@ -210,7 +245,7 @@ class ApplicationSource(pulumi.CustomResource):
     @overload
     def __init__(__self__,
                  resource_name: str,
-                 args: ApplicationSourceArgs,
+                 args: Optional[ApplicationSourceArgs] = None,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
         Application Source
@@ -221,9 +256,9 @@ class ApplicationSource(pulumi.CustomResource):
         import pulumi
         import pulumi_datarobot as datarobot
 
-        example = datarobot.ApplicationSource("example", local_files=[
-            "start-app.sh",
-            "streamlit-app.py",
+        example = datarobot.ApplicationSource("example", files=[
+            ["start-app.sh"],
+            ["streamlit-app.py"],
         ])
         pulumi.export("datarobotApplicationSourceId", example.id)
         pulumi.export("datarobotApplicationSourceVersionId", example.version_id)
@@ -244,7 +279,8 @@ class ApplicationSource(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 local_files: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 files: Optional[Any] = None,
+                 folder_path: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  resource_settings: Optional[pulumi.Input[Union['ApplicationSourceResourceSettingsArgs', 'ApplicationSourceResourceSettingsArgsDict']]] = None,
                  runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]]] = None,
@@ -257,9 +293,8 @@ class ApplicationSource(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = ApplicationSourceArgs.__new__(ApplicationSourceArgs)
 
-            if local_files is None and not opts.urn:
-                raise TypeError("Missing required property 'local_files'")
-            __props__.__dict__["local_files"] = local_files
+            __props__.__dict__["files"] = files
+            __props__.__dict__["folder_path"] = folder_path
             __props__.__dict__["name"] = name
             __props__.__dict__["resource_settings"] = resource_settings
             __props__.__dict__["runtime_parameter_values"] = runtime_parameter_values
@@ -274,7 +309,8 @@ class ApplicationSource(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
-            local_files: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+            files: Optional[Any] = None,
+            folder_path: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
             resource_settings: Optional[pulumi.Input[Union['ApplicationSourceResourceSettingsArgs', 'ApplicationSourceResourceSettingsArgsDict']]] = None,
             runtime_parameter_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]]] = None,
@@ -286,7 +322,8 @@ class ApplicationSource(pulumi.CustomResource):
         :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[Sequence[pulumi.Input[str]]] local_files: The list of local file paths used to build the Application Source.
+        :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[Union['ApplicationSourceResourceSettingsArgs', 'ApplicationSourceResourceSettingsArgsDict']] resource_settings: The resource settings for the Application Source.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationSourceRuntimeParameterValueArgs', 'ApplicationSourceRuntimeParameterValueArgsDict']]]] runtime_parameter_values: The runtime parameter values for the Application Source.
@@ -296,7 +333,8 @@ class ApplicationSource(pulumi.CustomResource):
 
         __props__ = _ApplicationSourceState.__new__(_ApplicationSourceState)
 
-        __props__.__dict__["local_files"] = local_files
+        __props__.__dict__["files"] = files
+        __props__.__dict__["folder_path"] = folder_path
         __props__.__dict__["name"] = name
         __props__.__dict__["resource_settings"] = resource_settings
         __props__.__dict__["runtime_parameter_values"] = runtime_parameter_values
@@ -304,12 +342,20 @@ class ApplicationSource(pulumi.CustomResource):
         return ApplicationSource(resource_name, opts=opts, __props__=__props__)
 
     @property
-    @pulumi.getter(name="localFiles")
-    def local_files(self) -> pulumi.Output[Sequence[str]]:
+    @pulumi.getter
+    def files(self) -> pulumi.Output[Optional[Any]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "files")
+
+    @property
+    @pulumi.getter(name="folderPath")
+    def folder_path(self) -> pulumi.Output[Optional[str]]:
         """
-        The list of local file paths used to build the Application Source.
+        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.
         """
-        return pulumi.get(self, "local_files")
+        return pulumi.get(self, "folder_path")
 
     @property
     @pulumi.getter

{pulumi_datarobot-0.1.31 → pulumi_datarobot-0.1.33}/pulumi_datarobot/custom_application.py

@@ -205,9 +205,9 @@ class CustomApplication(pulumi.CustomResource):
         import pulumi
         import pulumi_datarobot as datarobot
 
-        example_application_source = datarobot.ApplicationSource("exampleApplicationSource", local_files=[
-            "start-app.sh",
-            "streamlit-app.py",
+        example_application_source = datarobot.ApplicationSource("exampleApplicationSource", files=[
+            ["start-app.sh"],
+            ["streamlit-app.py"],
         ])
         example_custom_application = datarobot.CustomApplication("exampleCustomApplication",
             source_version_id=example_application_source.version_id,
@@ -241,9 +241,9 @@ class CustomApplication(pulumi.CustomResource):
         import pulumi
         import pulumi_datarobot as datarobot
 
-        example_application_source = datarobot.ApplicationSource("exampleApplicationSource", local_files=[
-            "start-app.sh",
-            "streamlit-app.py",
+        example_application_source = datarobot.ApplicationSource("exampleApplicationSource", files=[
+            ["start-app.sh"],
+            ["streamlit-app.py"],
         ])
         example_custom_application = datarobot.CustomApplication("exampleCustomApplication",
             source_version_id=example_application_source.version_id,