pulumi-gcp 8.33.0a1749001887__py3-none-any.whl → 8.34.0__py3-none-any.whl

pulumi_gcp/dataplex/outputs.py

@@ -60,6 +60,10 @@ __all__ = [
     'DatascanExecutionStatus',
     'DatascanIamBindingCondition',
     'DatascanIamMemberCondition',
+    'EntryAspect',
+    'EntryAspectAspect',
+    'EntryEntrySource',
+    'EntryEntrySourceAncestor',
     'EntryGroupIamBindingCondition',
     'EntryGroupIamMemberCondition',
     'EntryTypeIamBindingCondition',
@@ -1085,7 +1089,9 @@ class DatascanDataQualitySpec(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "postScanActions":
+        if key == "catalogPublishingEnabled":
+            suggest = "catalog_publishing_enabled"
+        elif key == "postScanActions":
             suggest = "post_scan_actions"
         elif key == "rowFilter":
             suggest = "row_filter"
@@ -1104,11 +1110,13 @@ class DatascanDataQualitySpec(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 catalog_publishing_enabled: Optional[builtins.bool] = None,
                  post_scan_actions: Optional['outputs.DatascanDataQualitySpecPostScanActions'] = None,
                  row_filter: Optional[builtins.str] = None,
                  rules: Optional[Sequence['outputs.DatascanDataQualitySpecRule']] = None,
                  sampling_percent: Optional[builtins.float] = None):
         """
+        :param builtins.bool catalog_publishing_enabled: If set, the latest DataScan job result will be published to Dataplex Catalog.
         :param 'DatascanDataQualitySpecPostScanActionsArgs' post_scan_actions: Actions to take upon job completion.
                Structure is documented below.
         :param builtins.str row_filter: A filter applied to all rows in a single DataScan job. The filter needs to be a valid SQL expression for a WHERE clause in BigQuery standard SQL syntax. Example: col1 >= 0 AND col2 < 10
@@ -1118,6 +1126,8 @@ class DatascanDataQualitySpec(dict):
                Value can range between 0.0 and 100.0 with up to 3 significant decimal digits.
                Sampling is not applied if `sampling_percent` is not specified, 0 or 100.
         """
+        if catalog_publishing_enabled is not None:
+            pulumi.set(__self__, "catalog_publishing_enabled", catalog_publishing_enabled)
         if post_scan_actions is not None:
             pulumi.set(__self__, "post_scan_actions", post_scan_actions)
         if row_filter is not None:
@@ -1127,6 +1137,14 @@ class DatascanDataQualitySpec(dict):
         if sampling_percent is not None:
             pulumi.set(__self__, "sampling_percent", sampling_percent)
 
+    @property
+    @pulumi.getter(name="catalogPublishingEnabled")
+    def catalog_publishing_enabled(self) -> Optional[builtins.bool]:
+        """
+        If set, the latest DataScan job result will be published to Dataplex Catalog.
+        """
+        return pulumi.get(self, "catalog_publishing_enabled")
+
     @property
     @pulumi.getter(name="postScanActions")
     def post_scan_actions(self) -> Optional['outputs.DatascanDataQualitySpecPostScanActions']:
@@ -2199,6 +2217,344 @@ class DatascanIamMemberCondition(dict):
         return pulumi.get(self, "description")
 
 
+@pulumi.output_type
+class EntryAspect(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aspectKey":
+            suggest = "aspect_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EntryAspect. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EntryAspect.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EntryAspect.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aspect: 'outputs.EntryAspectAspect',
+                 aspect_key: builtins.str):
+        """
+        :param 'EntryAspectAspectArgs' aspect: A nested object resource.
+               Structure is documented below.
+        :param builtins.str aspect_key: Depending on how the aspect is attached to the entry, the format of the aspect key can be one of the following:
+               If the aspect is attached directly to the entry: {project_number}.{locationId}.{aspectTypeId}
+               If the aspect is attached to an entry's path: {project_number}.{locationId}.{aspectTypeId}@{path}
+        """
+        pulumi.set(__self__, "aspect", aspect)
+        pulumi.set(__self__, "aspect_key", aspect_key)
+
+    @property
+    @pulumi.getter
+    def aspect(self) -> 'outputs.EntryAspectAspect':
+        """
+        A nested object resource.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "aspect")
+
+    @property
+    @pulumi.getter(name="aspectKey")
+    def aspect_key(self) -> builtins.str:
+        """
+        Depending on how the aspect is attached to the entry, the format of the aspect key can be one of the following:
+        If the aspect is attached directly to the entry: {project_number}.{locationId}.{aspectTypeId}
+        If the aspect is attached to an entry's path: {project_number}.{locationId}.{aspectTypeId}@{path}
+        """
+        return pulumi.get(self, "aspect_key")
+
+
+@pulumi.output_type
+class EntryAspectAspect(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aspectType":
+            suggest = "aspect_type"
+        elif key == "createTime":
+            suggest = "create_time"
+        elif key == "updateTime":
+            suggest = "update_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EntryAspectAspect. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EntryAspectAspect.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EntryAspectAspect.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 data: builtins.str,
+                 aspect_type: Optional[builtins.str] = None,
+                 create_time: Optional[builtins.str] = None,
+                 path: Optional[builtins.str] = None,
+                 update_time: Optional[builtins.str] = None):
+        """
+        :param builtins.str data: The content of the aspect in JSON form, according to its aspect type schema. The maximum size of the field is 120KB (encoded as UTF-8).
+        :param builtins.str aspect_type: (Output)
+               The resource name of the type used to create this Aspect.
+        :param builtins.str create_time: (Output)
+               The time when the Aspect was created.
+        :param builtins.str path: (Output)
+               The path in the entry under which the aspect is attached.
+        :param builtins.str update_time: (Output)
+               The time when the Aspect was last modified.
+        """
+        pulumi.set(__self__, "data", data)
+        if aspect_type is not None:
+            pulumi.set(__self__, "aspect_type", aspect_type)
+        if create_time is not None:
+            pulumi.set(__self__, "create_time", create_time)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if update_time is not None:
+            pulumi.set(__self__, "update_time", update_time)
+
+    @property
+    @pulumi.getter
+    def data(self) -> builtins.str:
+        """
+        The content of the aspect in JSON form, according to its aspect type schema. The maximum size of the field is 120KB (encoded as UTF-8).
+        """
+        return pulumi.get(self, "data")
+
+    @property
+    @pulumi.getter(name="aspectType")
+    def aspect_type(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The resource name of the type used to create this Aspect.
+        """
+        return pulumi.get(self, "aspect_type")
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The time when the Aspect was created.
+        """
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The path in the entry under which the aspect is attached.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter(name="updateTime")
+    def update_time(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The time when the Aspect was last modified.
+        """
+        return pulumi.get(self, "update_time")
+
+
+@pulumi.output_type
+class EntryEntrySource(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createTime":
+            suggest = "create_time"
+        elif key == "displayName":
+            suggest = "display_name"
+        elif key == "updateTime":
+            suggest = "update_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EntryEntrySource. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EntryEntrySource.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EntryEntrySource.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 ancestors: Optional[Sequence['outputs.EntryEntrySourceAncestor']] = None,
+                 create_time: Optional[builtins.str] = None,
+                 description: Optional[builtins.str] = None,
+                 display_name: Optional[builtins.str] = None,
+                 labels: Optional[Mapping[str, builtins.str]] = None,
+                 location: Optional[builtins.str] = None,
+                 platform: Optional[builtins.str] = None,
+                 resource: Optional[builtins.str] = None,
+                 system: Optional[builtins.str] = None,
+                 update_time: Optional[builtins.str] = None):
+        """
+        :param Sequence['EntryEntrySourceAncestorArgs'] ancestors: Structure is documented below.
+        :param builtins.str create_time: The time when the resource was created in the source system.
+        :param builtins.str description: A description of the data resource. Maximum length is 2,000 characters.
+        :param builtins.str display_name: A user-friendly display name. Maximum length is 500 characters.
+        :param Mapping[str, builtins.str] labels: User-defined labels. The maximum size of keys and values is 128 characters each.
+               An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
+        :param builtins.str location: (Output)
+               Location of the resource in the source system. You can search the entry by this location.
+               By default, this should match the location of the entry group containing this entry.
+               A different value allows capturing the source location for data external to Google Cloud.
+        :param builtins.str platform: The platform containing the source system. Maximum length is 64 characters.
+        :param builtins.str resource: The name of the resource in the source system. Maximum length is 4,000 characters.
+        :param builtins.str system: The name of the source system. Maximum length is 64 characters.
+        :param builtins.str update_time: The time when the resource was last updated in the source system.
+               If the entry exists in the system and its EntrySource has updateTime populated,
+               further updates to the EntrySource of the entry must provide incremental updates to its updateTime.
+        """
+        if ancestors is not None:
+            pulumi.set(__self__, "ancestors", ancestors)
+        if create_time is not None:
+            pulumi.set(__self__, "create_time", create_time)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if labels is not None:
+            pulumi.set(__self__, "labels", labels)
+        if location is not None:
+            pulumi.set(__self__, "location", location)
+        if platform is not None:
+            pulumi.set(__self__, "platform", platform)
+        if resource is not None:
+            pulumi.set(__self__, "resource", resource)
+        if system is not None:
+            pulumi.set(__self__, "system", system)
+        if update_time is not None:
+            pulumi.set(__self__, "update_time", update_time)
+
+    @property
+    @pulumi.getter
+    def ancestors(self) -> Optional[Sequence['outputs.EntryEntrySourceAncestor']]:
+        """
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ancestors")
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> Optional[builtins.str]:
+        """
+        The time when the resource was created in the source system.
+        """
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[builtins.str]:
+        """
+        A description of the data resource. Maximum length is 2,000 characters.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        A user-friendly display name. Maximum length is 500 characters.
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Optional[Mapping[str, builtins.str]]:
+        """
+        User-defined labels. The maximum size of keys and values is 128 characters each.
+        An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
+        """
+        return pulumi.get(self, "labels")
+
+    @property
+    @pulumi.getter
+    def location(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Location of the resource in the source system. You can search the entry by this location.
+        By default, this should match the location of the entry group containing this entry.
+        A different value allows capturing the source location for data external to Google Cloud.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def platform(self) -> Optional[builtins.str]:
+        """
+        The platform containing the source system. Maximum length is 64 characters.
+        """
+        return pulumi.get(self, "platform")
+
+    @property
+    @pulumi.getter
+    def resource(self) -> Optional[builtins.str]:
+        """
+        The name of the resource in the source system. Maximum length is 4,000 characters.
+        """
+        return pulumi.get(self, "resource")
+
+    @property
+    @pulumi.getter
+    def system(self) -> Optional[builtins.str]:
+        """
+        The name of the source system. Maximum length is 64 characters.
+        """
+        return pulumi.get(self, "system")
+
+    @property
+    @pulumi.getter(name="updateTime")
+    def update_time(self) -> Optional[builtins.str]:
+        """
+        The time when the resource was last updated in the source system.
+        If the entry exists in the system and its EntrySource has updateTime populated,
+        further updates to the EntrySource of the entry must provide incremental updates to its updateTime.
+        """
+        return pulumi.get(self, "update_time")
+
+
+@pulumi.output_type
+class EntryEntrySourceAncestor(dict):
+    def __init__(__self__, *,
+                 name: Optional[builtins.str] = None,
+                 type: Optional[builtins.str] = None):
+        """
+        :param builtins.str name: The name of the ancestor resource.
+        :param builtins.str type: The type of the ancestor resource.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[builtins.str]:
+        """
+        The name of the ancestor resource.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[builtins.str]:
+        """
+        The type of the ancestor resource.
+        """
+        return pulumi.get(self, "type")
+
+
 @pulumi.output_type
 class EntryGroupIamBindingCondition(dict):
     def __init__(__self__, *,

pulumi_gcp/datastream/_inputs.py

@@ -42,6 +42,8 @@ __all__ = [
     'ConnectionProfileSqlServerProfileArgsDict',
     'PrivateConnectionErrorArgs',
     'PrivateConnectionErrorArgsDict',
+    'PrivateConnectionPscInterfaceConfigArgs',
+    'PrivateConnectionPscInterfaceConfigArgsDict',
     'PrivateConnectionVpcPeeringConfigArgs',
     'PrivateConnectionVpcPeeringConfigArgsDict',
     'StreamBackfillAllArgs',
@@ -1461,13 +1463,57 @@ class PrivateConnectionErrorArgs:
         pulumi.set(self, "message", value)
 
 
+if not MYPY:
+    class PrivateConnectionPscInterfaceConfigArgsDict(TypedDict):
+        network_attachment: pulumi.Input[builtins.str]
+        """
+        Fully qualified name of the network attachment that Datastream will connect to.
+        Format: projects/{project}/regions/{region}/networkAttachments/{name}
+        To get Datastream project for the accepted list:
+        `gcloud datastream private-connections create [PC ID] --location=[LOCATION] --network-attachment=[NA URI] --validate-only --display-name=[ANY STRING]`
+        Add Datastream project to the attachment accepted list:
+        `gcloud compute network-attachments update [NA URI] --region=[NA region] --producer-accept-list=[TP from prev command]`
+        """
+elif False:
+    PrivateConnectionPscInterfaceConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PrivateConnectionPscInterfaceConfigArgs:
+    def __init__(__self__, *,
+                 network_attachment: pulumi.Input[builtins.str]):
+        """
+        :param pulumi.Input[builtins.str] network_attachment: Fully qualified name of the network attachment that Datastream will connect to.
+               Format: projects/{project}/regions/{region}/networkAttachments/{name}
+               To get Datastream project for the accepted list:
+               `gcloud datastream private-connections create [PC ID] --location=[LOCATION] --network-attachment=[NA URI] --validate-only --display-name=[ANY STRING]`
+               Add Datastream project to the attachment accepted list:
+               `gcloud compute network-attachments update [NA URI] --region=[NA region] --producer-accept-list=[TP from prev command]`
+        """
+        pulumi.set(__self__, "network_attachment", network_attachment)
+
+    @property
+    @pulumi.getter(name="networkAttachment")
+    def network_attachment(self) -> pulumi.Input[builtins.str]:
+        """
+        Fully qualified name of the network attachment that Datastream will connect to.
+        Format: projects/{project}/regions/{region}/networkAttachments/{name}
+        To get Datastream project for the accepted list:
+        `gcloud datastream private-connections create [PC ID] --location=[LOCATION] --network-attachment=[NA URI] --validate-only --display-name=[ANY STRING]`
+        Add Datastream project to the attachment accepted list:
+        `gcloud compute network-attachments update [NA URI] --region=[NA region] --producer-accept-list=[TP from prev command]`
+        """
+        return pulumi.get(self, "network_attachment")
+
+    @network_attachment.setter
+    def network_attachment(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "network_attachment", value)
+
+
 if not MYPY:
     class PrivateConnectionVpcPeeringConfigArgsDict(TypedDict):
         subnet: pulumi.Input[builtins.str]
         """
         A free subnet for peering. (CIDR of /29)
-
-        - - -
         """
         vpc: pulumi.Input[builtins.str]
         """
@@ -1484,8 +1530,6 @@ class PrivateConnectionVpcPeeringConfigArgs:
                  vpc: pulumi.Input[builtins.str]):
         """
         :param pulumi.Input[builtins.str] subnet: A free subnet for peering. (CIDR of /29)
-               
-               - - -
         :param pulumi.Input[builtins.str] vpc: Fully qualified name of the VPC that Datastream will peer to.
                Format: projects/{project}/global/{networks}/{name}
         """
@@ -1497,8 +1541,6 @@ class PrivateConnectionVpcPeeringConfigArgs:
     def subnet(self) -> pulumi.Input[builtins.str]:
         """
         A free subnet for peering. (CIDR of /29)
-
-        - - -
         """
         return pulumi.get(self, "subnet")
 

pulumi_gcp/datastream/outputs.py

@@ -30,6 +30,7 @@ __all__ = [
     'ConnectionProfileSalesforceProfileUserCredentials',
     'ConnectionProfileSqlServerProfile',
     'PrivateConnectionError',
+    'PrivateConnectionPscInterfaceConfig',
     'PrivateConnectionVpcPeeringConfig',
     'StreamBackfillAll',
     'StreamBackfillAllMysqlExcludedObjects',
@@ -1072,6 +1073,51 @@ class PrivateConnectionError(dict):
         return pulumi.get(self, "message")
 
 
+@pulumi.output_type
+class PrivateConnectionPscInterfaceConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "networkAttachment":
+            suggest = "network_attachment"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrivateConnectionPscInterfaceConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrivateConnectionPscInterfaceConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrivateConnectionPscInterfaceConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 network_attachment: builtins.str):
+        """
+        :param builtins.str network_attachment: Fully qualified name of the network attachment that Datastream will connect to.
+               Format: projects/{project}/regions/{region}/networkAttachments/{name}
+               To get Datastream project for the accepted list:
+               `gcloud datastream private-connections create [PC ID] --location=[LOCATION] --network-attachment=[NA URI] --validate-only --display-name=[ANY STRING]`
+               Add Datastream project to the attachment accepted list:
+               `gcloud compute network-attachments update [NA URI] --region=[NA region] --producer-accept-list=[TP from prev command]`
+        """
+        pulumi.set(__self__, "network_attachment", network_attachment)
+
+    @property
+    @pulumi.getter(name="networkAttachment")
+    def network_attachment(self) -> builtins.str:
+        """
+        Fully qualified name of the network attachment that Datastream will connect to.
+        Format: projects/{project}/regions/{region}/networkAttachments/{name}
+        To get Datastream project for the accepted list:
+        `gcloud datastream private-connections create [PC ID] --location=[LOCATION] --network-attachment=[NA URI] --validate-only --display-name=[ANY STRING]`
+        Add Datastream project to the attachment accepted list:
+        `gcloud compute network-attachments update [NA URI] --region=[NA region] --producer-accept-list=[TP from prev command]`
+        """
+        return pulumi.get(self, "network_attachment")
+
+
 @pulumi.output_type
 class PrivateConnectionVpcPeeringConfig(dict):
     def __init__(__self__, *,
@@ -1079,8 +1125,6 @@ class PrivateConnectionVpcPeeringConfig(dict):
                  vpc: builtins.str):
         """
         :param builtins.str subnet: A free subnet for peering. (CIDR of /29)
-               
-               - - -
         :param builtins.str vpc: Fully qualified name of the VPC that Datastream will peer to.
                Format: projects/{project}/global/{networks}/{name}
         """
@@ -1092,8 +1136,6 @@ class PrivateConnectionVpcPeeringConfig(dict):
     def subnet(self) -> builtins.str:
         """
         A free subnet for peering. (CIDR of /29)
-
-        - - -
         """
         return pulumi.get(self, "subnet")