pulumi-digitalocean 4.35.0a1731649402__tar.gz → 4.35.0a1732013080__tar.gz

{pulumi_digitalocean-4.35.0a1731649402 → pulumi_digitalocean-4.35.0a1732013080}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi_digitalocean
-Version: 4.35.0a1731649402
+Version: 4.35.0a1732013080
 Summary: A Pulumi package for creating and managing DigitalOcean cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_digitalocean-4.35.0a1731649402 → pulumi_digitalocean-4.35.0a1732013080}/pulumi_digitalocean/_inputs.py

@@ -208,6 +208,8 @@ __all__ = [
     'DatabaseUserSettingAclArgsDict',
     'DatabaseUserSettingOpensearchAclArgs',
     'DatabaseUserSettingOpensearchAclArgsDict',
+    'DropletBackupPolicyArgs',
+    'DropletBackupPolicyArgsDict',
     'FirewallInboundRuleArgs',
     'FirewallInboundRuleArgsDict',
     'FirewallOutboundRuleArgs',
@@ -9172,6 +9174,78 @@ class DatabaseUserSettingOpensearchAclArgs:
         pulumi.set(self, "permission", value)
 
 
+if not MYPY:
+    class DropletBackupPolicyArgsDict(TypedDict):
+        hour: NotRequired[pulumi.Input[int]]
+        """
+        The hour of the day that the backup window will start (`0`, `4`, `8`, `12`, `16`, `20`).
+        """
+        plan: NotRequired[pulumi.Input[str]]
+        """
+        The backup plan used for the Droplet. The plan can be either `daily` or `weekly`.
+        """
+        weekday: NotRequired[pulumi.Input[str]]
+        """
+        The day of the week on which the backup will occur (`SUN`, `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`).
+        """
+elif False:
+    DropletBackupPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DropletBackupPolicyArgs:
+    def __init__(__self__, *,
+                 hour: Optional[pulumi.Input[int]] = None,
+                 plan: Optional[pulumi.Input[str]] = None,
+                 weekday: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[int] hour: The hour of the day that the backup window will start (`0`, `4`, `8`, `12`, `16`, `20`).
+        :param pulumi.Input[str] plan: The backup plan used for the Droplet. The plan can be either `daily` or `weekly`.
+        :param pulumi.Input[str] weekday: The day of the week on which the backup will occur (`SUN`, `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`).
+        """
+        if hour is not None:
+            pulumi.set(__self__, "hour", hour)
+        if plan is not None:
+            pulumi.set(__self__, "plan", plan)
+        if weekday is not None:
+            pulumi.set(__self__, "weekday", weekday)
+
+    @property
+    @pulumi.getter
+    def hour(self) -> Optional[pulumi.Input[int]]:
+        """
+        The hour of the day that the backup window will start (`0`, `4`, `8`, `12`, `16`, `20`).
+        """
+        return pulumi.get(self, "hour")
+
+    @hour.setter
+    def hour(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "hour", value)
+
+    @property
+    @pulumi.getter
+    def plan(self) -> Optional[pulumi.Input[str]]:
+        """
+        The backup plan used for the Droplet. The plan can be either `daily` or `weekly`.
+        """
+        return pulumi.get(self, "plan")
+
+    @plan.setter
+    def plan(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "plan", value)
+
+    @property
+    @pulumi.getter
+    def weekday(self) -> Optional[pulumi.Input[str]]:
+        """
+        The day of the week on which the backup will occur (`SUN`, `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`).
+        """
+        return pulumi.get(self, "weekday")
+
+    @weekday.setter
+    def weekday(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "weekday", value)
+
+
 if not MYPY:
     class FirewallInboundRuleArgsDict(TypedDict):
         protocol: pulumi.Input[str]

{pulumi_digitalocean-4.35.0a1731649402 → pulumi_digitalocean-4.35.0a1732013080}/pulumi_digitalocean/database_redis_config.py

@@ -44,6 +44,8 @@ class DatabaseRedisConfigArgs:
         :param pulumi.Input[str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         :param pulumi.Input[int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
         :param pulumi.Input[bool] ssl: A boolean indicating whether to require SSL to access Redis.
+               - When enabled, Redis accepts only SSL connections on port `25061`.
+               - When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
         :param pulumi.Input[int] timeout: The Redis idle connection timeout in seconds.
         """
         pulumi.set(__self__, "cluster_id", cluster_id)
@@ -195,6 +197,8 @@ class DatabaseRedisConfigArgs:
     def ssl(self) -> Optional[pulumi.Input[bool]]:
         """
         A boolean indicating whether to require SSL to access Redis.
+        - When enabled, Redis accepts only SSL connections on port `25061`.
+        - When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
         """
         return pulumi.get(self, "ssl")
 
@@ -243,6 +247,8 @@ class _DatabaseRedisConfigState:
         :param pulumi.Input[str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         :param pulumi.Input[int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
         :param pulumi.Input[bool] ssl: A boolean indicating whether to require SSL to access Redis.
+               - When enabled, Redis accepts only SSL connections on port `25061`.
+               - When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
         :param pulumi.Input[int] timeout: The Redis idle connection timeout in seconds.
         """
         if acl_channels_default is not None:
@@ -395,6 +401,8 @@ class _DatabaseRedisConfigState:
     def ssl(self) -> Optional[pulumi.Input[bool]]:
         """
         A boolean indicating whether to require SSL to access Redis.
+        - When enabled, Redis accepts only SSL connections on port `25061`.
+        - When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
         """
         return pulumi.get(self, "ssl")
 
@@ -480,6 +488,8 @@ class DatabaseRedisConfig(pulumi.CustomResource):
         :param pulumi.Input[str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         :param pulumi.Input[int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
         :param pulumi.Input[bool] ssl: A boolean indicating whether to require SSL to access Redis.
+               - When enabled, Redis accepts only SSL connections on port `25061`.
+               - When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
         :param pulumi.Input[int] timeout: The Redis idle connection timeout in seconds.
         """
         ...
@@ -612,6 +622,8 @@ class DatabaseRedisConfig(pulumi.CustomResource):
         :param pulumi.Input[str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         :param pulumi.Input[int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
         :param pulumi.Input[bool] ssl: A boolean indicating whether to require SSL to access Redis.
+               - When enabled, Redis accepts only SSL connections on port `25061`.
+               - When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
         :param pulumi.Input[int] timeout: The Redis idle connection timeout in seconds.
         """
         opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
@@ -717,6 +729,8 @@ class DatabaseRedisConfig(pulumi.CustomResource):
     def ssl(self) -> pulumi.Output[bool]:
         """
         A boolean indicating whether to require SSL to access Redis.
+        - When enabled, Redis accepts only SSL connections on port `25061`.
+        - When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
         """
         return pulumi.get(self, "ssl")
 

{pulumi_digitalocean-4.35.0a1731649402 → pulumi_digitalocean-4.35.0a1732013080}/pulumi_digitalocean/droplet.py

@@ -13,7 +13,9 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
+from . import outputs
 from ._enums import *
+from ._inputs import *
 
 __all__ = ['DropletArgs', 'Droplet']
 
@@ -22,6 +24,7 @@ class DropletArgs:
     def __init__(__self__, *,
                  image: pulumi.Input[str],
                  size: pulumi.Input[Union[str, 'DropletSlug']],
+                 backup_policy: Optional[pulumi.Input['DropletBackupPolicyArgs']] = None,
                  backups: Optional[pulumi.Input[bool]] = None,
                  droplet_agent: Optional[pulumi.Input[bool]] = None,
                  graceful_shutdown: Optional[pulumi.Input[bool]] = None,
@@ -41,6 +44,7 @@ class DropletArgs:
         The set of arguments for constructing a Droplet resource.
         :param pulumi.Input[str] image: The Droplet image ID or slug. This could be either image ID or droplet snapshot ID.
         :param pulumi.Input[Union[str, 'DropletSlug']] size: The unique slug that identifies the type of Droplet. You can find a list of available slugs on [DigitalOcean API documentation](https://docs.digitalocean.com/reference/api/api-reference/#tag/Sizes).
+        :param pulumi.Input['DropletBackupPolicyArgs'] backup_policy: An object specifying the backup policy for the Droplet. If omitted and `backups` is `true`, the backup plan will default to daily.
         :param pulumi.Input[bool] backups: Boolean controlling if backups are made. Defaults to
                false.
         :param pulumi.Input[bool] droplet_agent: A boolean indicating whether to install the
@@ -82,6 +86,8 @@ class DropletArgs:
         """
         pulumi.set(__self__, "image", image)
         pulumi.set(__self__, "size", size)
+        if backup_policy is not None:
+            pulumi.set(__self__, "backup_policy", backup_policy)
         if backups is not None:
             pulumi.set(__self__, "backups", backups)
         if droplet_agent is not None:
@@ -140,6 +146,18 @@ class DropletArgs:
     def size(self, value: pulumi.Input[Union[str, 'DropletSlug']]):
         pulumi.set(self, "size", value)
 
+    @property
+    @pulumi.getter(name="backupPolicy")
+    def backup_policy(self) -> Optional[pulumi.Input['DropletBackupPolicyArgs']]:
+        """
+        An object specifying the backup policy for the Droplet. If omitted and `backups` is `true`, the backup plan will default to daily.
+        """
+        return pulumi.get(self, "backup_policy")
+
+    @backup_policy.setter
+    def backup_policy(self, value: Optional[pulumi.Input['DropletBackupPolicyArgs']]):
+        pulumi.set(self, "backup_policy", value)
+
     @property
     @pulumi.getter
     def backups(self) -> Optional[pulumi.Input[bool]]:
@@ -348,6 +366,7 @@ class DropletArgs:
 @pulumi.input_type
 class _DropletState:
     def __init__(__self__, *,
+                 backup_policy: Optional[pulumi.Input['DropletBackupPolicyArgs']] = None,
                  backups: Optional[pulumi.Input[bool]] = None,
                  created_at: Optional[pulumi.Input[str]] = None,
                  disk: Optional[pulumi.Input[int]] = None,
@@ -378,6 +397,7 @@ class _DropletState:
                  vpc_uuid: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering Droplet resources.
+        :param pulumi.Input['DropletBackupPolicyArgs'] backup_policy: An object specifying the backup policy for the Droplet. If omitted and `backups` is `true`, the backup plan will default to daily.
         :param pulumi.Input[bool] backups: Boolean controlling if backups are made. Defaults to
                false.
         :param pulumi.Input[int] disk: The size of the instance's disk in GB
@@ -428,6 +448,8 @@ class _DropletState:
         :param pulumi.Input[Sequence[pulumi.Input[str]]] volume_ids: A list of the IDs of each block storage volume to be attached to the Droplet.
         :param pulumi.Input[str] vpc_uuid: The ID of the VPC where the Droplet will be located.
         """
+        if backup_policy is not None:
+            pulumi.set(__self__, "backup_policy", backup_policy)
         if backups is not None:
             pulumi.set(__self__, "backups", backups)
         if created_at is not None:
@@ -488,6 +510,18 @@ class _DropletState:
         if vpc_uuid is not None:
             pulumi.set(__self__, "vpc_uuid", vpc_uuid)
 
+    @property
+    @pulumi.getter(name="backupPolicy")
+    def backup_policy(self) -> Optional[pulumi.Input['DropletBackupPolicyArgs']]:
+        """
+        An object specifying the backup policy for the Droplet. If omitted and `backups` is `true`, the backup plan will default to daily.
+        """
+        return pulumi.get(self, "backup_policy")
+
+    @backup_policy.setter
+    def backup_policy(self, value: Optional[pulumi.Input['DropletBackupPolicyArgs']]):
+        pulumi.set(self, "backup_policy", value)
+
     @property
     @pulumi.getter
     def backups(self) -> Optional[pulumi.Input[bool]]:
@@ -848,6 +882,7 @@ class Droplet(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 backup_policy: Optional[pulumi.Input[Union['DropletBackupPolicyArgs', 'DropletBackupPolicyArgsDict']]] = None,
                  backups: Optional[pulumi.Input[bool]] = None,
                  droplet_agent: Optional[pulumi.Input[bool]] = None,
                  graceful_shutdown: Optional[pulumi.Input[bool]] = None,
@@ -881,7 +916,13 @@ class Droplet(pulumi.CustomResource):
             image="ubuntu-20-04-x64",
             name="web-1",
             region=digitalocean.Region.NYC2,
-            size=digitalocean.DropletSlug.DROPLET_S1_VCPU1_GB)
+            size=digitalocean.DropletSlug.DROPLET_S1_VCPU1_GB,
+            backups=True,
+            backup_policy={
+                "plan": "weekly",
+                "weekday": "TUE",
+                "hour": 8,
+            })
         ```
 
         ## Import
@@ -894,6 +935,7 @@ class Droplet(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[Union['DropletBackupPolicyArgs', 'DropletBackupPolicyArgsDict']] backup_policy: An object specifying the backup policy for the Droplet. If omitted and `backups` is `true`, the backup plan will default to daily.
         :param pulumi.Input[bool] backups: Boolean controlling if backups are made. Defaults to
                false.
         :param pulumi.Input[bool] droplet_agent: A boolean indicating whether to install the
@@ -956,7 +998,13 @@ class Droplet(pulumi.CustomResource):
             image="ubuntu-20-04-x64",
             name="web-1",
             region=digitalocean.Region.NYC2,
-            size=digitalocean.DropletSlug.DROPLET_S1_VCPU1_GB)
+            size=digitalocean.DropletSlug.DROPLET_S1_VCPU1_GB,
+            backups=True,
+            backup_policy={
+                "plan": "weekly",
+                "weekday": "TUE",
+                "hour": 8,
+            })
         ```
 
         ## Import
@@ -982,6 +1030,7 @@ class Droplet(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 backup_policy: Optional[pulumi.Input[Union['DropletBackupPolicyArgs', 'DropletBackupPolicyArgsDict']]] = None,
                  backups: Optional[pulumi.Input[bool]] = None,
                  droplet_agent: Optional[pulumi.Input[bool]] = None,
                  graceful_shutdown: Optional[pulumi.Input[bool]] = None,
@@ -1008,6 +1057,7 @@ class Droplet(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = DropletArgs.__new__(DropletArgs)
 
+            __props__.__dict__["backup_policy"] = backup_policy
             __props__.__dict__["backups"] = backups
             __props__.__dict__["droplet_agent"] = droplet_agent
             __props__.__dict__["graceful_shutdown"] = graceful_shutdown
@@ -1050,6 +1100,7 @@ class Droplet(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            backup_policy: Optional[pulumi.Input[Union['DropletBackupPolicyArgs', 'DropletBackupPolicyArgsDict']]] = None,
             backups: Optional[pulumi.Input[bool]] = None,
             created_at: Optional[pulumi.Input[str]] = None,
             disk: Optional[pulumi.Input[int]] = None,
@@ -1085,6 +1136,7 @@ class Droplet(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[Union['DropletBackupPolicyArgs', 'DropletBackupPolicyArgsDict']] backup_policy: An object specifying the backup policy for the Droplet. If omitted and `backups` is `true`, the backup plan will default to daily.
         :param pulumi.Input[bool] backups: Boolean controlling if backups are made. Defaults to
                false.
         :param pulumi.Input[int] disk: The size of the instance's disk in GB
@@ -1139,6 +1191,7 @@ class Droplet(pulumi.CustomResource):
 
         __props__ = _DropletState.__new__(_DropletState)
 
+        __props__.__dict__["backup_policy"] = backup_policy
         __props__.__dict__["backups"] = backups
         __props__.__dict__["created_at"] = created_at
         __props__.__dict__["disk"] = disk
@@ -1169,6 +1222,14 @@ class Droplet(pulumi.CustomResource):
         __props__.__dict__["vpc_uuid"] = vpc_uuid
         return Droplet(resource_name, opts=opts, __props__=__props__)
 
+    @property
+    @pulumi.getter(name="backupPolicy")
+    def backup_policy(self) -> pulumi.Output[Optional['outputs.DropletBackupPolicy']]:
+        """
+        An object specifying the backup policy for the Droplet. If omitted and `backups` is `true`, the backup plan will default to daily.
+        """
+        return pulumi.get(self, "backup_policy")
+
     @property
     @pulumi.getter
     def backups(self) -> pulumi.Output[Optional[bool]]:

{pulumi_digitalocean-4.35.0a1731649402 → pulumi_digitalocean-4.35.0a1732013080}/pulumi_digitalocean/get_droplet.py

@@ -26,7 +26,7 @@ class GetDropletResult:
     """
     A collection of values returned by getDroplet.
     """
-    def __init__(__self__, backups=None, created_at=None, disk=None, id=None, image=None, ipv4_address=None, ipv4_address_private=None, ipv6=None, ipv6_address=None, ipv6_address_private=None, locked=None, memory=None, monitoring=None, name=None, price_hourly=None, price_monthly=None, private_networking=None, region=None, size=None, status=None, tag=None, tags=None, urn=None, vcpus=None, volume_ids=None, vpc_uuid=None):
+    def __init__(__self__, backups=None, created_at=None, disk=None, gpu=None, id=None, image=None, ipv4_address=None, ipv4_address_private=None, ipv6=None, ipv6_address=None, ipv6_address_private=None, locked=None, memory=None, monitoring=None, name=None, price_hourly=None, price_monthly=None, private_networking=None, region=None, size=None, status=None, tag=None, tags=None, urn=None, vcpus=None, volume_ids=None, vpc_uuid=None):
         if backups and not isinstance(backups, bool):
             raise TypeError("Expected argument 'backups' to be a bool")
         pulumi.set(__self__, "backups", backups)
@@ -36,6 +36,9 @@ class GetDropletResult:
         if disk and not isinstance(disk, int):
             raise TypeError("Expected argument 'disk' to be a int")
         pulumi.set(__self__, "disk", disk)
+        if gpu and not isinstance(gpu, bool):
+            raise TypeError("Expected argument 'gpu' to be a bool")
+        pulumi.set(__self__, "gpu", gpu)
         if id and not isinstance(id, int):
             raise TypeError("Expected argument 'id' to be a int")
         pulumi.set(__self__, "id", id)
@@ -127,6 +130,11 @@ class GetDropletResult:
         """
         return pulumi.get(self, "disk")
 
+    @property
+    @pulumi.getter
+    def gpu(self) -> Optional[bool]:
+        return pulumi.get(self, "gpu")
+
     @property
     @pulumi.getter
     def id(self) -> int:
@@ -315,6 +323,7 @@ class AwaitableGetDropletResult(GetDropletResult):
             backups=self.backups,
             created_at=self.created_at,
             disk=self.disk,
+            gpu=self.gpu,
             id=self.id,
             image=self.image,
             ipv4_address=self.ipv4_address,
@@ -340,7 +349,8 @@ class AwaitableGetDropletResult(GetDropletResult):
             vpc_uuid=self.vpc_uuid)
 
 
-def get_droplet(id: Optional[int] = None,
+def get_droplet(gpu: Optional[bool] = None,
+                id: Optional[int] = None,
                 name: Optional[str] = None,
                 tag: Optional[str] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDropletResult:
@@ -384,11 +394,15 @@ def get_droplet(id: Optional[int] = None,
     ```
 
 
+    :param bool gpu: A boolean value specifying whether or not to search GPU Droplets
     :param int id: The ID of the Droplet
     :param str name: The name of the Droplet.
     :param str tag: A tag applied to the Droplet.
+           
+           To include GPU Droplets when searching by name, use:
     """
     __args__ = dict()
+    __args__['gpu'] = gpu
     __args__['id'] = id
     __args__['name'] = name
     __args__['tag'] = tag
@@ -399,6 +413,7 @@ def get_droplet(id: Optional[int] = None,
         backups=pulumi.get(__ret__, 'backups'),
         created_at=pulumi.get(__ret__, 'created_at'),
         disk=pulumi.get(__ret__, 'disk'),
+        gpu=pulumi.get(__ret__, 'gpu'),
         id=pulumi.get(__ret__, 'id'),
         image=pulumi.get(__ret__, 'image'),
         ipv4_address=pulumi.get(__ret__, 'ipv4_address'),
@@ -422,7 +437,8 @@ def get_droplet(id: Optional[int] = None,
         vcpus=pulumi.get(__ret__, 'vcpus'),
         volume_ids=pulumi.get(__ret__, 'volume_ids'),
         vpc_uuid=pulumi.get(__ret__, 'vpc_uuid'))
-def get_droplet_output(id: Optional[pulumi.Input[Optional[int]]] = None,
+def get_droplet_output(gpu: Optional[pulumi.Input[Optional[bool]]] = None,
+                       id: Optional[pulumi.Input[Optional[int]]] = None,
                        name: Optional[pulumi.Input[Optional[str]]] = None,
                        tag: Optional[pulumi.Input[Optional[str]]] = None,
                        opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDropletResult]:
@@ -466,11 +482,15 @@ def get_droplet_output(id: Optional[pulumi.Input[Optional[int]]] = None,
     ```
 
 
+    :param bool gpu: A boolean value specifying whether or not to search GPU Droplets
     :param int id: The ID of the Droplet
     :param str name: The name of the Droplet.
     :param str tag: A tag applied to the Droplet.
+           
+           To include GPU Droplets when searching by name, use:
     """
     __args__ = dict()
+    __args__['gpu'] = gpu
     __args__['id'] = id
     __args__['name'] = name
     __args__['tag'] = tag
@@ -480,6 +500,7 @@ def get_droplet_output(id: Optional[pulumi.Input[Optional[int]]] = None,
         backups=pulumi.get(__response__, 'backups'),
         created_at=pulumi.get(__response__, 'created_at'),
         disk=pulumi.get(__response__, 'disk'),
+        gpu=pulumi.get(__response__, 'gpu'),
         id=pulumi.get(__response__, 'id'),
         image=pulumi.get(__response__, 'image'),
         ipv4_address=pulumi.get(__response__, 'ipv4_address'),

{pulumi_digitalocean-4.35.0a1731649402 → pulumi_digitalocean-4.35.0a1732013080}/pulumi_digitalocean/get_droplets.py

@@ -28,13 +28,16 @@ class GetDropletsResult:
     """
     A collection of values returned by getDroplets.
     """
-    def __init__(__self__, droplets=None, filters=None, id=None, sorts=None):
+    def __init__(__self__, droplets=None, filters=None, gpus=None, id=None, sorts=None):
         if droplets and not isinstance(droplets, list):
             raise TypeError("Expected argument 'droplets' to be a list")
         pulumi.set(__self__, "droplets", droplets)
         if filters and not isinstance(filters, list):
             raise TypeError("Expected argument 'filters' to be a list")
         pulumi.set(__self__, "filters", filters)
+        if gpus and not isinstance(gpus, bool):
+            raise TypeError("Expected argument 'gpus' to be a bool")
+        pulumi.set(__self__, "gpus", gpus)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
@@ -55,6 +58,11 @@ class GetDropletsResult:
     def filters(self) -> Optional[Sequence['outputs.GetDropletsFilterResult']]:
         return pulumi.get(self, "filters")
 
+    @property
+    @pulumi.getter
+    def gpus(self) -> Optional[bool]:
+        return pulumi.get(self, "gpus")
+
     @property
     @pulumi.getter
     def id(self) -> str:
@@ -77,11 +85,13 @@ class AwaitableGetDropletsResult(GetDropletsResult):
         return GetDropletsResult(
             droplets=self.droplets,
             filters=self.filters,
+            gpus=self.gpus,
             id=self.id,
             sorts=self.sorts)
 
 
 def get_droplets(filters: Optional[Sequence[Union['GetDropletsFilterArgs', 'GetDropletsFilterArgsDict']]] = None,
+                 gpus: Optional[bool] = None,
                  sorts: Optional[Sequence[Union['GetDropletsSortArgs', 'GetDropletsSortArgsDict']]] = None,
                  opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDropletsResult:
     """
@@ -91,6 +101,9 @@ def get_droplets(filters: Optional[Sequence[Union['GetDropletsFilterArgs', 'GetD
     This data source is useful if the Droplets in question are not managed by the provider or you need to
     utilize any of the Droplets' data.
 
+    By default, only non-GPU Droplets are returned. To list only GPU Droplets, set
+    the `gpus` attribute to `true`.
+
     Note: You can use the `Droplet` data source to obtain metadata
     about a single Droplet if you already know the `id`, unique `name`, or unique `tag` to retrieve.
 
@@ -135,11 +148,13 @@ def get_droplets(filters: Optional[Sequence[Union['GetDropletsFilterArgs', 'GetD
 
     :param Sequence[Union['GetDropletsFilterArgs', 'GetDropletsFilterArgsDict']] filters: Filter the results.
            The `filter` block is documented below.
+    :param bool gpus: A boolean value specifying whether or not to list GPU Droplets
     :param Sequence[Union['GetDropletsSortArgs', 'GetDropletsSortArgsDict']] sorts: Sort the results.
            The `sort` block is documented below.
     """
     __args__ = dict()
     __args__['filters'] = filters
+    __args__['gpus'] = gpus
     __args__['sorts'] = sorts
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('digitalocean:index/getDroplets:getDroplets', __args__, opts=opts, typ=GetDropletsResult).value
@@ -147,9 +162,11 @@ def get_droplets(filters: Optional[Sequence[Union['GetDropletsFilterArgs', 'GetD
     return AwaitableGetDropletsResult(
         droplets=pulumi.get(__ret__, 'droplets'),
         filters=pulumi.get(__ret__, 'filters'),
+        gpus=pulumi.get(__ret__, 'gpus'),
         id=pulumi.get(__ret__, 'id'),
         sorts=pulumi.get(__ret__, 'sorts'))
 def get_droplets_output(filters: Optional[pulumi.Input[Optional[Sequence[Union['GetDropletsFilterArgs', 'GetDropletsFilterArgsDict']]]]] = None,
+                        gpus: Optional[pulumi.Input[Optional[bool]]] = None,
                         sorts: Optional[pulumi.Input[Optional[Sequence[Union['GetDropletsSortArgs', 'GetDropletsSortArgsDict']]]]] = None,
                         opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDropletsResult]:
     """
@@ -159,6 +176,9 @@ def get_droplets_output(filters: Optional[pulumi.Input[Optional[Sequence[Union['
     This data source is useful if the Droplets in question are not managed by the provider or you need to
     utilize any of the Droplets' data.
 
+    By default, only non-GPU Droplets are returned. To list only GPU Droplets, set
+    the `gpus` attribute to `true`.
+
     Note: You can use the `Droplet` data source to obtain metadata
     about a single Droplet if you already know the `id`, unique `name`, or unique `tag` to retrieve.
 
@@ -203,16 +223,19 @@ def get_droplets_output(filters: Optional[pulumi.Input[Optional[Sequence[Union['
 
     :param Sequence[Union['GetDropletsFilterArgs', 'GetDropletsFilterArgsDict']] filters: Filter the results.
            The `filter` block is documented below.
+    :param bool gpus: A boolean value specifying whether or not to list GPU Droplets
     :param Sequence[Union['GetDropletsSortArgs', 'GetDropletsSortArgsDict']] sorts: Sort the results.
            The `sort` block is documented below.
     """
     __args__ = dict()
     __args__['filters'] = filters
+    __args__['gpus'] = gpus
     __args__['sorts'] = sorts
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('digitalocean:index/getDroplets:getDroplets', __args__, opts=opts, typ=GetDropletsResult)
     return __ret__.apply(lambda __response__: GetDropletsResult(
         droplets=pulumi.get(__response__, 'droplets'),
         filters=pulumi.get(__response__, 'filters'),
+        gpus=pulumi.get(__response__, 'gpus'),
         id=pulumi.get(__response__, 'id'),
         sorts=pulumi.get(__response__, 'sorts')))