pulumi-gcp 6.68.0a1698127103__py3-none-any.whl → 6.68.0a1698199636__py3-none-any.whl

pulumi_gcp/bigquerydatapolicy/get_iam_policy.py

@@ -103,17 +103,6 @@ def get_iam_policy(data_policy_id: Optional[str] = None,
     """
     Retrieves the current IAM policy data for datapolicy
 
-    ## example
-
-    ```python
-    import pulumi
-    import pulumi_gcp as gcp
-
-    policy = gcp.bigquerydatapolicy.get_iam_policy(project=google_bigquery_datapolicy_data_policy["data_policy"]["project"],
-        location=google_bigquery_datapolicy_data_policy["data_policy"]["location"],
-        data_policy_id=google_bigquery_datapolicy_data_policy["data_policy"]["data_policy_id"])
-    ```
-
 
     :param str location: The name of the location of the data policy.
            Used to find the parent resource to bind the IAM policy to
@@ -144,17 +133,6 @@ def get_iam_policy_output(data_policy_id: Optional[pulumi.Input[str]] = None,
     """
     Retrieves the current IAM policy data for datapolicy
 
-    ## example
-
-    ```python
-    import pulumi
-    import pulumi_gcp as gcp
-
-    policy = gcp.bigquerydatapolicy.get_iam_policy(project=google_bigquery_datapolicy_data_policy["data_policy"]["project"],
-        location=google_bigquery_datapolicy_data_policy["data_policy"]["location"],
-        data_policy_id=google_bigquery_datapolicy_data_policy["data_policy"]["data_policy_id"])
-    ```
-
 
     :param str location: The name of the location of the data policy.
            Used to find the parent resource to bind the IAM policy to

pulumi_gcp/bigquerydatapolicy/outputs.py

@@ -47,8 +47,14 @@ class DataPolicyDataMaskingPolicy(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             predefined_expression: str,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             predefined_expression: Optional[str] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if predefined_expression is None and 'predefinedExpression' in kwargs:
+            predefined_expression = kwargs['predefinedExpression']
+        if predefined_expression is None:
+            raise TypeError("Missing 'predefined_expression' argument")
+
         _setter("predefined_expression", predefined_expression)
 
     @property
@@ -76,10 +82,16 @@ class DataPolicyIamBindingCondition(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: str,
-             title: str,
+             expression: Optional[str] = None,
+             title: Optional[str] = None,
              description: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:
@@ -116,10 +128,16 @@ class DataPolicyIamMemberCondition(dict):
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: str,
-             title: str,
+             expression: Optional[str] = None,
+             title: Optional[str] = None,
              description: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:

pulumi_gcp/bigtable/_inputs.py

@@ -42,7 +42,9 @@ class GCPolicyMaxAgeArgs:
              _setter: Callable[[Any, Any], None],
              days: Optional[pulumi.Input[int]] = None,
              duration: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if days is not None:
             warnings.warn("""Deprecated in favor of duration""", DeprecationWarning)
             pulumi.log.warn("""days is deprecated: Deprecated in favor of duration""")
@@ -98,8 +100,12 @@ class GCPolicyMaxVersionArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             number: pulumi.Input[int],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             number: Optional[pulumi.Input[int]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if number is None:
+            raise TypeError("Missing 'number' argument")
+
         _setter("number", number)
 
     @property
@@ -160,13 +166,27 @@ class InstanceClusterArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             cluster_id: pulumi.Input[str],
+             cluster_id: Optional[pulumi.Input[str]] = None,
              autoscaling_config: Optional[pulumi.Input['InstanceClusterAutoscalingConfigArgs']] = None,
              kms_key_name: Optional[pulumi.Input[str]] = None,
              num_nodes: Optional[pulumi.Input[int]] = None,
              storage_type: Optional[pulumi.Input[str]] = None,
              zone: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if cluster_id is None and 'clusterId' in kwargs:
+            cluster_id = kwargs['clusterId']
+        if cluster_id is None:
+            raise TypeError("Missing 'cluster_id' argument")
+        if autoscaling_config is None and 'autoscalingConfig' in kwargs:
+            autoscaling_config = kwargs['autoscalingConfig']
+        if kms_key_name is None and 'kmsKeyName' in kwargs:
+            kms_key_name = kwargs['kmsKeyName']
+        if num_nodes is None and 'numNodes' in kwargs:
+            num_nodes = kwargs['numNodes']
+        if storage_type is None and 'storageType' in kwargs:
+            storage_type = kwargs['storageType']
+
         _setter("cluster_id", cluster_id)
         if autoscaling_config is not None:
             _setter("autoscaling_config", autoscaling_config)
@@ -290,11 +310,27 @@ class InstanceClusterAutoscalingConfigArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             cpu_target: pulumi.Input[int],
-             max_nodes: pulumi.Input[int],
-             min_nodes: pulumi.Input[int],
+             cpu_target: Optional[pulumi.Input[int]] = None,
+             max_nodes: Optional[pulumi.Input[int]] = None,
+             min_nodes: Optional[pulumi.Input[int]] = None,
              storage_target: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if cpu_target is None and 'cpuTarget' in kwargs:
+            cpu_target = kwargs['cpuTarget']
+        if cpu_target is None:
+            raise TypeError("Missing 'cpu_target' argument")
+        if max_nodes is None and 'maxNodes' in kwargs:
+            max_nodes = kwargs['maxNodes']
+        if max_nodes is None:
+            raise TypeError("Missing 'max_nodes' argument")
+        if min_nodes is None and 'minNodes' in kwargs:
+            min_nodes = kwargs['minNodes']
+        if min_nodes is None:
+            raise TypeError("Missing 'min_nodes' argument")
+        if storage_target is None and 'storageTarget' in kwargs:
+            storage_target = kwargs['storageTarget']
+
         _setter("cpu_target", cpu_target)
         _setter("max_nodes", max_nodes)
         _setter("min_nodes", min_nodes)
@@ -367,10 +403,16 @@ class InstanceIamBindingConditionArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: pulumi.Input[str],
-             title: pulumi.Input[str],
+             expression: Optional[pulumi.Input[str]] = None,
+             title: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:
@@ -419,10 +461,16 @@ class InstanceIamMemberConditionArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: pulumi.Input[str],
-             title: pulumi.Input[str],
+             expression: Optional[pulumi.Input[str]] = None,
+             title: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:
@@ -470,8 +518,12 @@ class TableColumnFamilyArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             family: pulumi.Input[str],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             family: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if family is None:
+            raise TypeError("Missing 'family' argument")
+
         _setter("family", family)
 
     @property
@@ -502,10 +554,16 @@ class TableIamBindingConditionArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: pulumi.Input[str],
-             title: pulumi.Input[str],
+             expression: Optional[pulumi.Input[str]] = None,
+             title: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:
@@ -554,10 +612,16 @@ class TableIamMemberConditionArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             expression: pulumi.Input[str],
-             title: pulumi.Input[str],
+             expression: Optional[pulumi.Input[str]] = None,
+             title: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if expression is None:
+            raise TypeError("Missing 'expression' argument")
+        if title is None:
+            raise TypeError("Missing 'title' argument")
+
         _setter("expression", expression)
         _setter("title", title)
         if description is not None:

pulumi_gcp/bigtable/gc_policy.py

@@ -57,16 +57,36 @@ class GCPolicyArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             column_family: pulumi.Input[str],
-             instance_name: pulumi.Input[str],
-             table: pulumi.Input[str],
+             column_family: Optional[pulumi.Input[str]] = None,
+             instance_name: Optional[pulumi.Input[str]] = None,
+             table: Optional[pulumi.Input[str]] = None,
              deletion_policy: Optional[pulumi.Input[str]] = None,
              gc_rules: Optional[pulumi.Input[str]] = None,
              max_age: Optional[pulumi.Input['GCPolicyMaxAgeArgs']] = None,
              max_versions: Optional[pulumi.Input[Sequence[pulumi.Input['GCPolicyMaxVersionArgs']]]] = None,
              mode: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if column_family is None and 'columnFamily' in kwargs:
+            column_family = kwargs['columnFamily']
+        if column_family is None:
+            raise TypeError("Missing 'column_family' argument")
+        if instance_name is None and 'instanceName' in kwargs:
+            instance_name = kwargs['instanceName']
+        if instance_name is None:
+            raise TypeError("Missing 'instance_name' argument")
+        if table is None:
+            raise TypeError("Missing 'table' argument")
+        if deletion_policy is None and 'deletionPolicy' in kwargs:
+            deletion_policy = kwargs['deletionPolicy']
+        if gc_rules is None and 'gcRules' in kwargs:
+            gc_rules = kwargs['gcRules']
+        if max_age is None and 'maxAge' in kwargs:
+            max_age = kwargs['maxAge']
+        if max_versions is None and 'maxVersions' in kwargs:
+            max_versions = kwargs['maxVersions']
+
         _setter("column_family", column_family)
         _setter("instance_name", instance_name)
         _setter("table", table)
@@ -250,7 +270,21 @@ class _GCPolicyState:
              mode: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
              table: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if column_family is None and 'columnFamily' in kwargs:
+            column_family = kwargs['columnFamily']
+        if deletion_policy is None and 'deletionPolicy' in kwargs:
+            deletion_policy = kwargs['deletionPolicy']
+        if gc_rules is None and 'gcRules' in kwargs:
+            gc_rules = kwargs['gcRules']
+        if instance_name is None and 'instanceName' in kwargs:
+            instance_name = kwargs['instanceName']
+        if max_age is None and 'maxAge' in kwargs:
+            max_age = kwargs['maxAge']
+        if max_versions is None and 'maxVersions' in kwargs:
+            max_versions = kwargs['maxVersions']
+
         if column_family is not None:
             _setter("column_family", column_family)
         if deletion_policy is not None:
@@ -413,110 +447,6 @@ class GCPolicy(pulumi.CustomResource):
         The workaround is unreplicating the instance first by updating the instance to have one
         cluster.
 
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        instance = gcp.bigtable.Instance("instance", clusters=[gcp.bigtable.InstanceClusterArgs(
-            cluster_id="tf-instance-cluster",
-            num_nodes=3,
-            storage_type="HDD",
-        )])
-        table = gcp.bigtable.Table("table",
-            instance_name=instance.name,
-            column_families=[gcp.bigtable.TableColumnFamilyArgs(
-                family="name",
-            )])
-        policy = gcp.bigtable.GCPolicy("policy",
-            instance_name=instance.name,
-            table=table.name,
-            column_family="name",
-            deletion_policy="ABANDON",
-            gc_rules=\"\"\"  {
-            "rules": [
-              {
-                "max_age": "168h"
-              }
-            ]
-          }
-        \"\"\")
-        ```
-
-        Multiple conditions is also supported. `UNION` when any of its sub-policies apply (OR). `INTERSECTION` when all its sub-policies apply (AND)
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        policy = gcp.bigtable.GCPolicy("policy",
-            instance_name=google_bigtable_instance["instance"]["name"],
-            table=google_bigtable_table["table"]["name"],
-            column_family="name",
-            deletion_policy="ABANDON",
-            gc_rules=\"\"\"  {
-            "mode": "union",
-            "rules": [
-              {
-                "max_age": "168h"
-              },
-              {
-                "max_version": 10
-              }
-            ]
-          }
-        \"\"\")
-        ```
-
-        An example of more complex GC policy:
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        instance = gcp.bigtable.Instance("instance",
-            clusters=[gcp.bigtable.InstanceClusterArgs(
-                cluster_id="cid",
-                zone="us-central1-b",
-            )],
-            instance_type="DEVELOPMENT",
-            deletion_protection=False)
-        table = gcp.bigtable.Table("table",
-            instance_name=instance.id,
-            column_families=[gcp.bigtable.TableColumnFamilyArgs(
-                family="cf1",
-            )])
-        policy = gcp.bigtable.GCPolicy("policy",
-            instance_name=instance.id,
-            table=table.name,
-            column_family="cf1",
-            deletion_policy="ABANDON",
-            gc_rules=\"\"\"  {
-            "mode": "union",
-            "rules": [
-              {
-                "max_age": "10h"
-              },
-              {
-                "mode": "intersection",
-                "rules": [
-                  {
-                    "max_age": "2h"
-                  },
-                  {
-                    "max_version": 2
-                  }
-                ]
-              }
-            ]
-          }
-        \"\"\")
-        ```
-        This is equivalent to running the following `cbt` command:
-        ```python
-        import pulumi
-        ```
-
         ## Import
 
         This resource does not support import.
@@ -558,110 +488,6 @@ class GCPolicy(pulumi.CustomResource):
         The workaround is unreplicating the instance first by updating the instance to have one
         cluster.
 
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        instance = gcp.bigtable.Instance("instance", clusters=[gcp.bigtable.InstanceClusterArgs(
-            cluster_id="tf-instance-cluster",
-            num_nodes=3,
-            storage_type="HDD",
-        )])
-        table = gcp.bigtable.Table("table",
-            instance_name=instance.name,
-            column_families=[gcp.bigtable.TableColumnFamilyArgs(
-                family="name",
-            )])
-        policy = gcp.bigtable.GCPolicy("policy",
-            instance_name=instance.name,
-            table=table.name,
-            column_family="name",
-            deletion_policy="ABANDON",
-            gc_rules=\"\"\"  {
-            "rules": [
-              {
-                "max_age": "168h"
-              }
-            ]
-          }
-        \"\"\")
-        ```
-
-        Multiple conditions is also supported. `UNION` when any of its sub-policies apply (OR). `INTERSECTION` when all its sub-policies apply (AND)
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        policy = gcp.bigtable.GCPolicy("policy",
-            instance_name=google_bigtable_instance["instance"]["name"],
-            table=google_bigtable_table["table"]["name"],
-            column_family="name",
-            deletion_policy="ABANDON",
-            gc_rules=\"\"\"  {
-            "mode": "union",
-            "rules": [
-              {
-                "max_age": "168h"
-              },
-              {
-                "max_version": 10
-              }
-            ]
-          }
-        \"\"\")
-        ```
-
-        An example of more complex GC policy:
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        instance = gcp.bigtable.Instance("instance",
-            clusters=[gcp.bigtable.InstanceClusterArgs(
-                cluster_id="cid",
-                zone="us-central1-b",
-            )],
-            instance_type="DEVELOPMENT",
-            deletion_protection=False)
-        table = gcp.bigtable.Table("table",
-            instance_name=instance.id,
-            column_families=[gcp.bigtable.TableColumnFamilyArgs(
-                family="cf1",
-            )])
-        policy = gcp.bigtable.GCPolicy("policy",
-            instance_name=instance.id,
-            table=table.name,
-            column_family="cf1",
-            deletion_policy="ABANDON",
-            gc_rules=\"\"\"  {
-            "mode": "union",
-            "rules": [
-              {
-                "max_age": "10h"
-              },
-              {
-                "mode": "intersection",
-                "rules": [
-                  {
-                    "max_age": "2h"
-                  },
-                  {
-                    "max_version": 2
-                  }
-                ]
-              }
-            ]
-          }
-        \"\"\")
-        ```
-        This is equivalent to running the following `cbt` command:
-        ```python
-        import pulumi
-        ```
-
         ## Import
 
         This resource does not support import.
@@ -711,11 +537,7 @@ class GCPolicy(pulumi.CustomResource):
             if instance_name is None and not opts.urn:
                 raise TypeError("Missing required property 'instance_name'")
             __props__.__dict__["instance_name"] = instance_name
-            if max_age is not None and not isinstance(max_age, GCPolicyMaxAgeArgs):
-                max_age = max_age or {}
-                def _setter(key, value):
-                    max_age[key] = value
-                GCPolicyMaxAgeArgs._configure(_setter, **max_age)
+            max_age = _utilities.configure(max_age, GCPolicyMaxAgeArgs, True)
             __props__.__dict__["max_age"] = max_age
             __props__.__dict__["max_versions"] = max_versions
             __props__.__dict__["mode"] = mode

pulumi_gcp/bigtable/get_instance_iam_policy.py

@@ -92,15 +92,6 @@ def get_instance_iam_policy(instance: Optional[str] = None,
     """
     Retrieves the current IAM policy data for a Bigtable instance.
 
-    ## example
-
-    ```python
-    import pulumi
-    import pulumi_gcp as gcp
-
-    policy = gcp.bigtable.get_instance_iam_policy(instance=google_bigtable_instance["instance"]["name"])
-    ```
-
 
     :param str instance: The name or relative resource id of the instance to manage IAM policies for.
     """
@@ -125,15 +116,6 @@ def get_instance_iam_policy_output(instance: Optional[pulumi.Input[str]] = None,
     """
     Retrieves the current IAM policy data for a Bigtable instance.
 
-    ## example
-
-    ```python
-    import pulumi
-    import pulumi_gcp as gcp
-
-    policy = gcp.bigtable.get_instance_iam_policy(instance=google_bigtable_instance["instance"]["name"])
-    ```
-
 
     :param str instance: The name or relative resource id of the instance to manage IAM policies for.
     """

pulumi_gcp/bigtable/get_table_iam_policy.py

@@ -102,16 +102,6 @@ def get_table_iam_policy(instance: Optional[str] = None,
     """
     Retrieves the current IAM policy data for a Bigtable Table.
 
-    ## example
-
-    ```python
-    import pulumi
-    import pulumi_gcp as gcp
-
-    policy = gcp.bigtable.get_table_iam_policy(instance=google_bigtable_instance["instance"]["name"],
-        table=google_bigtable_table["table"]["name"])
-    ```
-
 
     :param str instance: The name or relative resource id of the instance that owns the table.
     :param str table: The name or relative resource id of the table to manage IAM policies for.
@@ -140,16 +130,6 @@ def get_table_iam_policy_output(instance: Optional[pulumi.Input[str]] = None,
     """
     Retrieves the current IAM policy data for a Bigtable Table.
 
-    ## example
-
-    ```python
-    import pulumi
-    import pulumi_gcp as gcp
-
-    policy = gcp.bigtable.get_table_iam_policy(instance=google_bigtable_instance["instance"]["name"],
-        table=google_bigtable_table["table"]["name"])
-    ```
-
 
     :param str instance: The name or relative resource id of the instance that owns the table.
     :param str table: The name or relative resource id of the table to manage IAM policies for.