o tBhm@sdZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddl"m#Z#ddl$m%Z%ddl$m&Z&ddl$m'Z'ddl$m(Z(ddl$m)Z)ddl$m*Z*ddl$m+Z+ddl$m,Z,ddl$m-Z-ddl$m.Z.dd l$m/Z/dd!l$m0Z0dd"l1m2Z2dd#l1m3Z3dd$l4m5Z5dd%l4m6Z6dd&l4m7Z7dd'l4m8Z8d(Z9d)Z:d*Z;d+Zd.d/Z?d0d1Z@d2d3ZAGd4d5d5eBZCGd6d7d7eBZDGd8d9d9eBZEeFZGGd:d;d;eBZHGdd?ZJdS)@z4Create / interact with Google Cloud Storage buckets.N)urlsplit)datetime_helpers)_datetime_to_rfc3339)_NOW)_rfc3339_nanos_to_datetime)NotFound)Policy)_signing)_add_etag_match_headers) _add_generation_match_parameters)_PropertyMixin)_scalar_property)_validate_name)generate_signed_url_v2)generate_signed_url_v4)_bucket_bound_hostname_url) BucketACL)DefaultObjectACLBlob)_DEFAULT_TIMEOUT)ARCHIVE_STORAGE_CLASS)COLDLINE_STORAGE_CLASS)DUAL_REGION_LOCATION_TYPE)1DURABLE_REDUCED_AVAILABILITY_LEGACY_STORAGE_CLASS)#MULTI_REGIONAL_LEGACY_STORAGE_CLASS)MULTI_REGION_LOCATION_TYPE)NEARLINE_STORAGE_CLASS)$PUBLIC_ACCESS_PREVENTION_UNSPECIFIED)REGIONAL_LEGACY_STORAGE_CLASS)REGION_LOCATION_TYPE)STANDARD_STORAGE_CLASSBucketNotification)NONE_PAYLOAD_FORMAT) DEFAULT_RETRY)%DEFAULT_RETRY_IF_GENERATION_SPECIFIED)DEFAULT_RETRY_IF_ETAG_IN_JSON))DEFAULT_RETRY_IF_METAGENERATION_SPECIFIEDzlPass only one of 'uniform_bucket_level_access_enabled' / 'bucket_policy_only_enabled' to 'IAMConfiguration'.z'IAMConfiguration.bucket_policy_only_enabled' is deprecated. Instead, use 'IAMConfiguration.uniform_bucket_level_access_enabled'.zpPass only one of 'uniform_bucket_level_access_lock_time' / 'bucket_policy_only_lock_time' to 'IAMConfiguration'.z'IAMConfiguration.bucket_policy_only_lock_time' is deprecated. Instead, use 'IAMConfiguration.uniform_bucket_level_access_lock_time'.zAssignment to 'Bucket.location' is deprecated, as it is only valid before the bucket is created. Instead, pass the location to `Bucket.create`.zhttps://storage.googleapis.comcCs$t|dd|_|j|jdS)aGrab prefixes after a :class:`~google.cloud.iterator.Page` started. :type iterator: :class:`~google.api_core.page_iterator.Iterator` :param iterator: The iterator that is currently in use. :type page: :class:`~google.cloud.api.core.page_iterator.Page` :param page: The page that was just created. :type response: dict :param response: The JSON API response for a page of blobs. prefixesN)tuplegetr)update)iteratorpageresponser*r*r/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/google/cloud/storage/bucket.py_blobs_page_startZs r2cCs&|d}t||jd}|||S)aConvert a JSON blob to the native object. .. note:: This assumes that the ``bucket`` attribute has been added to the iterator after being created. :type iterator: :class:`~google.api_core.page_iterator.Iterator` :param iterator: The iterator that has retrieved the item. :type item: dict :param item: An item to be converted to a blob. :rtype: :class:`.Blob` :returns: The next blob in the page. namebucket)r,rr5_set_properties)r.itemr3blobr*r*r1 _item_to_blobjs  r9cCstj||jdS)aConvert a JSON blob to the native object. .. note:: This assumes that the ``bucket`` attribute has been added to the iterator after being created. :type iterator: :class:`~google.api_core.page_iterator.Iterator` :param iterator: The iterator that has retrieved the item. :type item: dict :param item: An item to be converted to a blob. :rtype: :class:`.BucketNotification` :returns: The next notification being iterated. r4)r# from_api_reprr5)r.r7r*r*r1_item_to_notificationsr;cseZdZdZ          dfdd ZeddZedd Zed d Z ed d Z eddZ eddZ eddZ eddZeddZeddZZS)LifecycleRuleConditionsa Map a single lifecycle rule for a bucket. See: https://cloud.google.com/storage/docs/lifecycle :type age: int :param age: (Optional) Apply rule action to items whose age, in days, exceeds this value. :type created_before: datetime.date :param created_before: (Optional) Apply rule action to items created before this date. :type is_live: bool :param is_live: (Optional) If true, apply rule action to non-versioned items, or to items with no newer versions. If false, apply rule action to versioned items with at least one newer version. :type matches_storage_class: list(str), one or more of :attr:`Bucket.STORAGE_CLASSES`. :param matches_storage_class: (Optional) Apply rule action to items which whose storage class matches this value. :type number_of_newer_versions: int :param number_of_newer_versions: (Optional) Apply rule action to versioned items having N newer versions. :type days_since_custom_time: int :param days_since_custom_time: (Optional) Apply rule action to items whose number of days elapsed since the custom timestamp. This condition is relevant only for versioned objects. The value of the field must be a non negative integer. If it's zero, the object version will become eligible for lifecycle action as soon as it becomes custom. :type custom_time_before: :class:`datetime.date` :param custom_time_before: (Optional) Date object parsed from RFC3339 valid date, apply rule action to items whose custom time is before this date. This condition is relevant only for versioned objects, e.g., 2019-03-16. :type days_since_noncurrent_time: int :param days_since_noncurrent_time: (Optional) Apply rule action to items whose number of days elapsed since the non current timestamp. This condition is relevant only for versioned objects. The value of the field must be a non negative integer. If it's zero, the object version will become eligible for lifecycle action as soon as it becomes non current. :type noncurrent_time_before: :class:`datetime.date` :param noncurrent_time_before: (Optional) Date object parsed from RFC3339 valid date, apply rule action to items whose non current time is before this date. This condition is relevant only for versioned objects, e.g, 2019-03-16. :raises ValueError: if no arguments are passed. NFc si} |dur || d<|dur|| d<|dur|| d<|dur$|| d<|dur,|| d<|dur4|| d<|dur>|| d<| sF| sFtd|durN|| d <| durX| | d <tt|| dS) Nage createdBeforeisLivematchesStorageClassnumNewerVersionsdaysSinceCustomTimecustomTimeBeforezSupply at least one conditiondaysSinceNoncurrentTimenoncurrentTimeBefore) isoformat ValueErrorsuperr<__init__) selfr=created_beforeis_livematches_storage_classnumber_of_newer_versionsdays_since_custom_timecustom_time_beforedays_since_noncurrent_timenoncurrent_time_before_factory conditions __class__r*r1rIs,    z LifecycleRuleConditions.__init__cC|dd}|||S)zFactory: construct instance from resource. :type resource: dict :param resource: mapping as returned from API call. :rtype: :class:`LifecycleRuleConditions` :returns: Instance created from resource. TrSr-clsresourceinstancer*r*r1r: z%LifecycleRuleConditions.from_api_reprcC |dS)zConditon's age value.r=r,rJr*r*r1r=  zLifecycleRuleConditions.agecC |d}|durt|SdS)z Conditon's created_before value.r>Nr,rfrom_iso8601_daterJbeforer*r*r1rK  z&LifecycleRuleConditions.created_beforecCr_)zConditon's 'is_live' value.r?r`rar*r*r1rLrbzLifecycleRuleConditions.is_livecCr_)z)Conditon's 'matches_storage_class' value.r@r`rar*r*r1rMrbz-LifecycleRuleConditions.matches_storage_classcCr_)z,Conditon's 'number_of_newer_versions' value.rAr`rar*r*r1rN rbz0LifecycleRuleConditions.number_of_newer_versionscCr_)z*Conditon's 'days_since_custom_time' value.rBr`rar*r*r1rO%rbz.LifecycleRuleConditions.days_since_custom_timecCrc)z&Conditon's 'custom_time_before' value.rCNrdrfr*r*r1rP*rhz*LifecycleRuleConditions.custom_time_beforecCr_)z.Conditon's 'days_since_noncurrent_time' value.rDr`rar*r*r1rQ1rbz2LifecycleRuleConditions.days_since_noncurrent_timecCrc)z*Conditon's 'noncurrent_time_before' value.rENrdrfr*r*r1rR6rhz.LifecycleRuleConditions.noncurrent_time_before) NNNNNNNNNF)__name__ __module__ __qualname____doc__rI classmethodr:propertyr=rKrLrMrNrOrPrQrR __classcell__r*r*rUr1r<sB9/         r<c,eZdZdZfddZeddZZS)LifecycleRuleDeletezMap a lifecycle rule deleting matching items. :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. c s4tdi|}ddit|d}tt||dS)NtypeDeleteaction conditionr*)r<dictrHrqrI)rJkwrTrulerUr*r1rIEszLifecycleRuleDelete.__init__cCrW)Factory: construct instance from resource. :type resource: dict :param resource: mapping as returned from API call. :rtype: :class:`LifecycleRuleDelete` :returns: Instance created from resource. TrXrYrZr*r*r1r:Jr^z!LifecycleRuleDelete.from_api_reprrirjrkrlrIrmr:ror*r*rUr1rq>s  rqcrp)LifecycleRuleSetStorageClassa,Map a lifecycle rule updating storage class of matching items. :type storage_class: str, one of :attr:`Bucket.STORAGE_CLASSES`. :param storage_class: new storage class to assign to matching items. :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. c s6tdi|}d|dt|d}tt||dS)NSetStorageClass)rr storageClassrtr*)r<rwrHr|rI)rJ storage_classrxrTryrUr*r1rIcs z%LifecycleRuleSetStorageClass.__init__cCs&|d}||ddd}|||S)rzrur~TrXrY)r[r\rur]r*r*r1r:ks  z*LifecycleRuleSetStorageClass.from_api_reprr{r*r*rUr1r|Ys  r|cseZdZdZeeeeeffdd ZeddZeddZ edd Z e j d d Z ed d Z e j d d Z eddZ eddZej ddZeddZZS)IAMConfigurationaMap a bucket's IAM configuration. :type bucket: :class:`Bucket` :params bucket: Bucket for which this instance is the policy. :type public_access_prevention: str :params public_access_prevention: (Optional) Whether the public access prevention policy is 'unspecified' (default) or 'enforced' See: https://cloud.google.com/storage/docs/public-access-prevention See: https://cloud.google.com/storage/docs/public-access-prevention :type uniform_bucket_level_access_enabled: bool :params bucket_policy_only_enabled: (Optional) Whether the IAM-only policy is enabled for the bucket. :type uniform_bucket_level_access_locked_time: :class:`datetime.datetime` :params uniform_bucket_level_locked_time: (Optional) When the bucket's IAM-only policy was enabled. This value should normally only be set by the back-end API. :type bucket_policy_only_enabled: bool :params bucket_policy_only_enabled: Deprecated alias for :data:`uniform_bucket_level_access_enabled`. :type bucket_policy_only_locked_time: :class:`datetime.datetime` :params bucket_policy_only_locked_time: Deprecated alias for :data:`uniform_bucket_level_access_locked_time`. cs|tur|tur tttjttdd|}|tur,|tur"tttjttdd|}|tur2d}|tur8t }d|i|d}|turKt ||dd<t t | |||_dS)N stacklevelFenabled)uniformBucketLevelAccesspublicAccessPreventionr lockedTime)_defaultrG_UBLA_BPO_ENABLED_MESSAGEwarningswarn_BPO_ENABLED_MESSAGEDeprecationWarning_UBLA_BPO_LOCK_TIME_MESSAGE_BPO_LOCK_TIME_MESSAGErrrHrrI_bucket)rJr5public_access_prevention#uniform_bucket_level_access_enabled'uniform_bucket_level_access_locked_timebucket_policy_only_enabledbucket_policy_only_locked_timedatarUr*r1rIs0   zIAMConfiguration.__init__cCs||}|||S)aXFactory: construct instance from resource. :type bucket: :class:`Bucket` :params bucket: Bucket for which this instance is the policy. :type resource: dict :param resource: mapping as returned from API call. :rtype: :class:`IAMConfiguration` :returns: Instance created from resource. rY)r[r\r5r]r*r*r1r:s zIAMConfiguration.from_api_reprcC|jS)zBucket for which this instance is the policy. :rtype: :class:`Bucket` :returns: the instance's bucket. )rrar*r*r1r5zIAMConfiguration.bucketcCs|dS)aGSetting for public access prevention policy. Options are 'unspecified' (default) or 'enforced'. More information can be found at https://cloud.google.com/storage/docs/public-access-prevention :rtype: string :returns: the public access prevention status, either 'enforced' or 'unspecified'. rr*rar*r*r1rsz)IAMConfiguration.public_access_preventioncCs||d<|jd|dS)NriamConfiguration)r5_patch_propertyrJvaluer*r*r1rscCs|di}|ddS)zIf set, access checks only use bucket-level IAM policies or above. :rtype: bool :returns: whether the bucket is configured to allow only IAM. rrFr`)rJublar*r*r1rs  z4IAMConfiguration.uniform_bucket_level_access_enabledcCs*|di}t||d<|jd|dS)Nrrr) setdefaultboolr5r)rJrrr*r*r1rs  cCs*|di}|d}|durt|}|S)a,Deadline for changing :attr:`uniform_bucket_level_access_enabled` from true to false. If the bucket's :attr:`uniform_bucket_level_access_enabled` is true, this property is time time after which that setting becomes immutable. If the bucket's :attr:`uniform_bucket_level_access_enabled` is false, this property is ``None``. :rtype: Union[:class:`datetime.datetime`, None] :returns: (readonly) Time after which :attr:`uniform_bucket_level_access_enabled` will be frozen as true. rrN)r,r)rJrstampr*r*r1rs  z8IAMConfiguration.uniform_bucket_level_access_locked_timecCr)zDeprecated alias for :attr:`uniform_bucket_level_access_enabled`. :rtype: bool :returns: whether the bucket is configured to allow only IAM. )rrar*r*r1rrz+IAMConfiguration.bucket_policy_only_enabledcCstjttdd||_dS)Nrr)rrrrrrr*r*r1rs cCr)aDeprecated alias for :attr:`uniform_bucket_level_access_locked_time`. :rtype: Union[:class:`datetime.datetime`, None] :returns: (readonly) Time after which :attr:`bucket_policy_only_enabled` will be frozen as true. )rrar*r*r1r#s z/IAMConfiguration.bucket_policy_only_locked_time)rirjrkrlrrIrmr:rnr5rsetterrrrrror*r*rUr1r~s8 ,         rcseZdZdZdZ eeeee e e fZ e eefZ dfdd ZddZedd Zfd d Zed d ZedddZ    dddZdddddedfddZdeddddefddZdddddeefddZdedde ffdd Z!ddeddddeffdd Z"dedde ffdd Z#edd Z$ed!d"Z%e&d#d$Z'ed%d&Z(dddddddddeef d'd(Z)dddddddddddeef d)d*Z*deefd+d,Z+deefd-d.Z,d/dddeefd0d1Z-ddddddee.fd2d3Z/ddedddde.fd4d5Z0ddd6dddddddddee.fd7d8Z1dddddddddee.f d9d:Z2ed;d<Z3e3j4d=d<Z3e5d>Z6 ed?d@Z7e7j4dAd@Z7edBdCZ8e8j4dDdCZ8edEdFZ9edGdHZ:edIdJZ;edKdLZdRdSZ?e5dTZ@edUdVZAeAj4dWdVZAedXdYZBdZd[ZCdd]d^ZDd_d`ZEedadbZFedcddZGededfZHedgdhZIedidjZJedkdlZKeKj4dmdlZKedndoZLedpdqZMeMj4drdqZMedsdtZNedudvZOeOj4dwdvZOedxdyZPePj4dzdyZPdd{d|ZQd}d~ZRddeefddZSdeeTfddZUdeefddZVd/d/defddZWd/d/defddZXdddZYdeefddZZde[ddddddd/ddf ddZ\Z]S)Bucketa&A class representing a Bucket on Cloud Storage. :type client: :class:`google.cloud.storage.client.Client` :param client: A client which holds credentials and project configuration for the bucket (which requires a project). :type name: str :param name: The name of the bucket. Bucket names must start and end with a number or letter. :type user_project: str :param user_project: (Optional) the project ID to be billed for API requests made via this instance. NcsFt|}tt|j|d||_t||_t||_t |_ ||_ dS)zJ property :attr:`name` Get the bucket's name. r3N) rrHrrI_clientr_aclr_default_object_aclset_label_removals _user_project)rJclientr3 user_projectrUr*r1rI^s   zBucket.__init__cCs d|jfS)Nz rrar*r*r1__repr__ks zBucket.__repr__cCr)z The client bound to this bucket.)rrar*r*r1rnz Bucket.clientcs|jtt||S)zSet the properties for the current object. :type value: dict or :class:`google.cloud.storage.batch._FutureDict` :param value: The properties to be set. )rclearrHrr6rrUr*r1r6ss zBucket._set_propertiescCr)aJProject ID to be billed for API requests made via this bucket. If unset, API requests are billed to the bucket owner. A user project is required for all operations on Requester Pays buckets. See https://cloud.google.com/storage/docs/requester-pays#requirements for details. :rtype: str )rrar*r*r1r|s zBucket.user_projectcCs.t|\}}}}}|dkrtd|||dS)aGet a constructor for bucket object by URI. :type uri: str :param uri: The bucket uri pass to get bucket object. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. :rtype: :class:`google.cloud.storage.bucket.Bucket` :returns: The bucket object created. Example: Get a constructor for bucket object by URI.. >>> from google.cloud import storage >>> from google.cloud.storage.bucket import Bucket >>> client = storage.Client() >>> bucket = Bucket.from_string("gs://bucket", client) gszURI scheme must be gsr)rrG)r[urirschemenetlocpathqueryfragr*r*r1 from_strings zBucket.from_stringcCst||||||dS)aFactory constructor for blob object. .. note:: This will not make an HTTP request; it simply instantiates a blob object owned by this bucket. :type blob_name: str :param blob_name: The name of the blob to be instantiated. :type chunk_size: int :param chunk_size: The size of a chunk of data whenever iterating (in bytes). This must be a multiple of 256 KB per the API specification. :type encryption_key: bytes :param encryption_key: (Optional) 32 byte encryption key for customer-supplied encryption. :type kms_key_name: str :param kms_key_name: (Optional) Resource name of KMS key used to encrypt blob's content. :type generation: long :param generation: (Optional) If present, selects a specific revision of this object. :rtype: :class:`google.cloud.storage.blob.Blob` :returns: The blob object created. )r3r5 chunk_sizeencryption_key kms_key_name generationr)rJ blob_namerrrrr*r*r1r8s%z Bucket.blobc Cst||||||||dS)zFactory: create a notification resource for the bucket. See: :class:`.BucketNotification` for parameters. :rtype: :class:`.BucketNotification` ) topic_name topic_projectcustom_attributes event_typesblob_name_prefixpayload_formatnotification_idr")rJrrrrrrrr*r*r1 notificationszBucket.notificationc Csz||}ddi}|jdur|j|d<t|||di} t| ||dz|j|j|| ||ddWd Sty<YdSw) aDetermines whether or not this bucket exists. If :attr:`user_project` is set, bills the API request to that project. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type if_etag_match: Union[str, Set[str]] :param if_etag_match: (Optional) Make the operation conditional on whether the bucket's current ETag matches the given value. :type if_etag_not_match: Union[str, Set[str]]) :param if_etag_not_match: (Optional) Make the operation conditional on whether the bucket's current ETag does not match the given value. :type if_metageneration_match: long :param if_metageneration_match: (Optional) Make the operation conditional on whether the bucket's current metageneration matches the given value. :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) Make the operation conditional on whether the bucket's current metageneration does not match the given value. :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: bool :returns: True if the bucket exists in Cloud Storage. fieldsr3N userProjectif_metageneration_matchif_metageneration_not_match) if_etag_matchif_etag_not_match) query_paramsheaderstimeoutretry_target_objectFT)_require_clientrr r _get_resourcerr) rJrrrrrrrrrr*r*r1existss4 /   z Bucket.existsc Cs:tjdtdd||}|j|||j|||||ddS)aIDEPRECATED. Creates current bucket. .. note:: Direct use of this method is deprecated. Use ``Client.create_bucket()`` instead. If the bucket already exists, will raise :class:`google.cloud.exceptions.Conflict`. This implements "storage.buckets.insert". If :attr:`user_project` is set, bills the API request to that project. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type project: str :param project: (Optional) The project under which the bucket is to be created. If not passed, uses the project set on the client. :raises ValueError: if ``project`` is None and client's :attr:`project` is also None. :type location: str :param location: (Optional) The location of the bucket. If not passed, the default location, US, will be used. See https://cloud.google.com/storage/docs/bucket-locations :type predefined_acl: str :param predefined_acl: (Optional) Name of predefined ACL to apply to bucket. See: https://cloud.google.com/storage/docs/access-control/lists#predefined-acl :type predefined_default_object_acl: str :param predefined_default_object_acl: (Optional) Name of predefined ACL to apply to bucket's objects. See: https://cloud.google.com/storage/docs/access-control/lists#predefined-acl :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` z_Bucket.create() is deprecated and will be removed in future.Use Client.create_bucket() instead.r)bucket_or_nameprojectrlocationpredefined_aclpredefined_default_object_aclrrN)rrPendingDeprecationWarningr create_bucketr)rJrrrrrrrr*r*r1createDs :  z Bucket.createcstt|j|||||ddS)a9Sends all properties in a PUT request. Updates the ``_properties`` with the response from the backend. If :attr:`user_project` is set, bills the API request to that project. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: the client to use. If not passed, falls back to the ``client`` stored on the current object. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type if_metageneration_match: long :param if_metageneration_match: (Optional) Make the operation conditional on whether the blob's current metageneration matches the given value. :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) Make the operation conditional on whether the blob's current metageneration does not match the given value. :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` )rrrrrN)rHrr-)rJrrrrrrUr*r1r-s $ z Bucket.updatenoAclc s$tt|j||||||||ddS)aReload properties from Cloud Storage. If :attr:`user_project` is set, bills the API request to that project. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: the client to use. If not passed, falls back to the ``client`` stored on the current object. :type projection: str :param projection: (Optional) If used, must be 'full' or 'noAcl'. Defaults to ``'noAcl'``. Specifies the set of properties to return. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type if_etag_match: Union[str, Set[str]] :param if_etag_match: (Optional) Make the operation conditional on whether the bucket's current ETag matches the given value. :type if_etag_not_match: Union[str, Set[str]]) :param if_etag_not_match: (Optional) Make the operation conditional on whether the bucket's current ETag does not match the given value. :type if_metageneration_match: long :param if_metageneration_match: (Optional) Make the operation conditional on whether the bucket's current metageneration matches the given value. :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) Make the operation conditional on whether the bucket's current metageneration does not match the given value. :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` )r projectionrrrrrrN)rHrreload) rJrrrrrrrrrUr*r1rs 2 z Bucket.reloadcsX|jr|jd|jdi|jD] }d|jd|<qtt|j|||||ddS)aCSends all changed properties in a PATCH request. Updates the ``_properties`` with the response from the backend. If :attr:`user_project` is set, bills the API request to that project. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: the client to use. If not passed, falls back to the ``client`` stored on the current object. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type if_metageneration_match: long :param if_metageneration_match: (Optional) Make the operation conditional on whether the blob's current metageneration matches the given value. :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) Make the operation conditional on whether the blob's current metageneration does not match the given value. :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` labelsN)rrrrr)r_changesadd _propertiesrrHrpatch)rJrrrrr removed_labelrUr*r1rs&    z Bucket.patchcCr)zCreate our ACL on demand.)rrar*r*r1acl/rz Bucket.aclcCr)z&Create our defaultObjectACL on demand.)rrar*r*r1default_object_acl4rzBucket.default_object_aclcCsd|S)zRelative URL path for a bucket. :type bucket_name: str :param bucket_name: The bucket name in the path. :rtype: str :returns: The relative URL path for ``bucket_name``. z/b/r* bucket_namer*r*r1 path_helper9s zBucket.path_helpercCs|jstd||jS)zThe URL path to this bucket.z*Cannot determine path without bucket name.)r3rGrrar*r*r1rEs z Bucket.pathc  KsPtd||||d| }z|j|| ||||| | | d W|Sty'YdSw)a Get a blob object by name. This will return None if the blob doesn't exist: .. literalinclude:: snippets.py :start-after: [START get_blob] :end-before: [END get_blob] :dedent: 4 If :attr:`user_project` is set, bills the API request to that project. :type blob_name: str :param blob_name: The name of the blob to retrieve. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type encryption_key: bytes :param encryption_key: (Optional) 32 byte encryption key for customer-supplied encryption. See https://cloud.google.com/storage/docs/encryption#customer-supplied. :type generation: long :param generation: (Optional) If present, selects a specific revision of this object. :type if_etag_match: Union[str, Set[str]] :param if_etag_match: (Optional) See :ref:`using-if-etag-match` :type if_etag_not_match: Union[str, Set[str]] :param if_etag_not_match: (Optional) See :ref:`using-if-etag-not-match` :type if_generation_match: long :param if_generation_match: (Optional) See :ref:`using-if-generation-match` :type if_generation_not_match: long :param if_generation_not_match: (Optional) See :ref:`using-if-generation-not-match` :type if_metageneration_match: long :param if_metageneration_match: (Optional) See :ref:`using-if-metageneration-match` :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) See :ref:`using-if-metageneration-not-match` :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :param kwargs: Keyword arguments to pass to the :class:`~google.cloud.storage.blob.Blob` constructor. :rtype: :class:`google.cloud.storage.blob.Blob` or None :returns: The blob object if it exists, otherwise None. )r5r3rr) rrrrif_generation_matchif_generation_not_matchrrrNr*)rrr)rJrrrrrrrrrrrrkwargsr8r*r*r1get_blobMs0T zBucket.get_blobcCs.|| } | j|||||||||| | | | d S)aiDEPRECATED. Return an iterator used to find blobs in the bucket. .. note:: Direct use of this method is deprecated. Use ``Client.list_blobs`` instead. If :attr:`user_project` is set, bills the API request to that project. :type max_results: int :param max_results: (Optional) The maximum number of blobs to return. :type page_token: str :param page_token: (Optional) If present, return the next batch of blobs, using the value, which must correspond to the ``nextPageToken`` value returned in the previous response. Deprecated: use the ``pages`` property of the returned iterator instead of manually passing the token. :type prefix: str :param prefix: (Optional) Prefix used to filter blobs. :type delimiter: str :param delimiter: (Optional) Delimiter, used with ``prefix`` to emulate hierarchy. :type start_offset: str :param start_offset: (Optional) Filter results to objects whose names are lexicographically equal to or after ``startOffset``. If ``endOffset`` is also set, the objects listed will have names between ``startOffset`` (inclusive) and ``endOffset`` (exclusive). :type end_offset: str :param end_offset: (Optional) Filter results to objects whose names are lexicographically before ``endOffset``. If ``startOffset`` is also set, the objects listed will have names between ``startOffset`` (inclusive) and ``endOffset`` (exclusive). :type include_trailing_delimiter: boolean :param include_trailing_delimiter: (Optional) If true, objects that end in exactly one instance of ``delimiter`` will have their metadata included in ``items`` in addition to ``prefixes``. :type versions: bool :param versions: (Optional) Whether object versions should be returned as separate blobs. :type projection: str :param projection: (Optional) If used, must be 'full' or 'noAcl'. Defaults to ``'noAcl'``. Specifies the set of properties to return. :type fields: str :param fields: (Optional) Selector specifying which fields to include in a partial response. Must be a list of fields. For example to get a partial response with just the next page token and the name and language of each blob returned: ``'items(name,contentLanguage),nextPageToken'``. See: https://cloud.google.com/storage/docs/json_api/v1/parameters#fields :type client: :class:`~google.cloud.storage.client.Client` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: :class:`~google.api_core.page_iterator.Iterator` :returns: Iterator of all :class:`~google.cloud.storage.blob.Blob` in this bucket matching the arguments. Example: List blobs in the bucket with user_project. >>> from google.cloud import storage >>> client = storage.Client() >>> bucket = storage.Bucket(client, "my-bucket-name", user_project="my-project") >>> all_blobs = list(client.list_blobs(bucket)) ) max_results page_tokenprefix delimiter start_offset end_offsetinclude_trailing_delimiterversionsrrrr)r list_blobs)rJrrrrrrrrrrrrrr*r*r1rs jzBucket.list_blobscCs0||}|jd}|j|t||d}||_|S)aList Pub / Sub notifications for this bucket. See: https://cloud.google.com/storage/docs/json_api/v1/notifications/list If :attr:`user_project` is set, bills the API request to that project. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: list of :class:`.BucketNotification` :returns: notification instances z/notificationConfigs)rr)rr_list_resourcer;r5)rJrrrrr.r*r*r1list_notifications7s  zBucket.list_notificationscCs |j|d}|j|||d|S)aGet Pub / Sub notification for this bucket. See: https://cloud.google.com/storage/docs/json_api/v1/notifications/get If :attr:`user_project` is set, bills the API request to that project. :type notification_id: str :param notification_id: The notification id to retrieve the notification configuration. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: :class:`.BucketNotification` :returns: notification instance. Example: Get notification using notification id. >>> from google.cloud import storage >>> client = storage.Client() >>> bucket = client.get_bucket('my-bucket-name') # API request. >>> notification = bucket.get_notification(notification_id='id') # API request. )r)rrr)rr)rJrrrrrr*r*r1get_notificationYs *zBucket.get_notificationFc Cs||}i}|jdur|j|d<t|||d|rEt|j|jd|||d}t||jkr9d|jf} t| |j|dd|||d |j |j |||dd dS) aDelete this bucket. The bucket **must** be empty in order to submit a delete request. If ``force=True`` is passed, this will first attempt to delete all the objects / blobs in the bucket (i.e. try to empty the bucket). If the bucket doesn't exist, this will raise :class:`google.cloud.exceptions.NotFound`. If the bucket is not empty (and ``force=False``), will raise :class:`google.cloud.exceptions.Conflict`. If ``force=True`` and the bucket contains more than 256 objects / blobs this will cowardly refuse to delete the objects (or the bucket). This is to prevent accidental bucket deletion and to prevent extremely long runtime of this method. If :attr:`user_project` is set, bills the API request to that project. :type force: bool :param force: If True, empties the bucket's objects then deletes it. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type if_metageneration_match: long :param if_metageneration_match: (Optional) Make the operation conditional on whether the blob's current metageneration matches the given value. :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) Make the operation conditional on whether the blob's current metageneration does not match the given value. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :raises: :class:`ValueError` if ``force`` is ``True`` and the bucket contains more than 256 objects / blobs. Nrrr)rrrrzRefusing to delete bucket with more than %d objects. If you actually want to delete this bucket, please delete the objects yourself before calling Bucket.delete().cSsdSNr*)r8r*r*r1szBucket.delete..)on_errorrrrrrrr) rrr listr_MAX_OBJECTS_FOR_ITERATIONlenrG delete_blobs_delete_resourcer) rJforcerrrrrrblobsmessager*r*r1deletesJ 6    z Bucket.deletec CsP||}t|||d} t| j} t| ||||d|j| j| || dddS)aDeletes a blob from the current bucket. If the blob isn't found (backend 404), raises a :class:`google.cloud.exceptions.NotFound`. For example: .. literalinclude:: snippets.py :start-after: [START delete_blob] :end-before: [END delete_blob] :dedent: 4 If :attr:`user_project` is set, bills the API request to that project. :type blob_name: str :param blob_name: A blob name to delete. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type generation: long :param generation: (Optional) If present, permanently deletes a specific revision of this object. :type if_generation_match: long :param if_generation_match: (Optional) See :ref:`using-if-generation-match` :type if_generation_not_match: long :param if_generation_not_match: (Optional) See :ref:`using-if-generation-not-match` :type if_metageneration_match: long :param if_metageneration_match: (Optional) See :ref:`using-if-metageneration-match` :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) See :ref:`using-if-metageneration-not-match` :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :raises: :class:`google.cloud.exceptions.NotFound` (to suppress the exception, call ``delete_blobs``, passing a no-op ``on_error`` callback, e.g.: .. literalinclude:: snippets.py :start-after: [START delete_blobs] :end-before: [END delete_blobs] :dedent: 4 )r5rrrrrNr)rrcopydeepcopy _query_paramsr rr) rJrrrrrrrrrr8rr*r*r1 delete_blobs" I   zBucket.delete_blobc Cstt|||||dt|pg}t|pg}t|pg}t|p!g}|D];} z&| } t| tjs3| j} |j| |t|dt|dt|dt|d|| dWq%t y`|dur]|| nYq%wdS)a Deletes a list of blobs from the current bucket. Uses :meth:`delete_blob` to delete each individual blob. If :attr:`user_project` is set, bills the API request to that project. :type blobs: list :param blobs: A list of :class:`~google.cloud.storage.blob.Blob`-s or blob names to delete. :type on_error: callable :param on_error: (Optional) Takes single argument: ``blob``. Called called once for each blob raising :class:`~google.cloud.exceptions.NotFound`; otherwise, the exception is propagated. :type client: :class:`~google.cloud.storage.client.Client` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type if_generation_match: list of long :param if_generation_match: (Optional) See :ref:`using-if-generation-match` Note that the length of the list must match the length of The list must match ``blobs`` item-to-item. :type if_generation_not_match: list of long :param if_generation_not_match: (Optional) See :ref:`using-if-generation-not-match` The list must match ``blobs`` item-to-item. :type if_metageneration_match: list of long :param if_metageneration_match: (Optional) See :ref:`using-if-metageneration-match` The list must match ``blobs`` item-to-item. :type if_metageneration_not_match: list of long :param if_metageneration_not_match: (Optional) See :ref:`using-if-metageneration-not-match` The list must match ``blobs`` item-to-item. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :raises: :class:`~google.cloud.exceptions.NotFound` (if `on_error` is not passed). Example: Delete blobs using generation match preconditions. >>> from google.cloud import storage >>> client = storage.Client() >>> bucket = client.bucket("bucket-name") >>> blobs = [bucket.blob("blob-name-1"), bucket.blob("blob-name-2")] >>> if_generation_match = [None] * len(blobs) >>> if_generation_match[0] = "123" # precondition for "blob-name-1" >>> bucket.delete_blobs(blobs, if_generation_match=if_generation_match) rN)rrrrrrr) _raise_if_len_differsriter isinstancesix string_typesr3r nextr) rJrrrrrrrrrr8rr*r*r1rMsBO       zBucket.delete_blobsTc Cs||}i}|jdur|j|d<|dur||d<t|||| | | | | |d |dur-|j}t||d}|jd|j}|j|d||||d}|sQ|jji||d| ||S) aCopy the given blob to the given bucket, optionally with a new name. If :attr:`user_project` is set, bills the API request to that project. :type blob: :class:`google.cloud.storage.blob.Blob` :param blob: The blob to be copied. :type destination_bucket: :class:`google.cloud.storage.bucket.Bucket` :param destination_bucket: The bucket into which the blob should be copied. :type new_name: str :param new_name: (Optional) The new name for the copied file. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type preserve_acl: bool :param preserve_acl: DEPRECATED. This argument is not functional! (Optional) Copies ACL from old blob to new blob. Default: True. :type source_generation: long :param source_generation: (Optional) The generation of the blob to be copied. :type if_generation_match: long :param if_generation_match: (Optional) See :ref:`using-if-generation-match` Note that the generation to be matched is that of the ``destination`` blob. :type if_generation_not_match: long :param if_generation_not_match: (Optional) See :ref:`using-if-generation-not-match` Note that the generation to be matched is that of the ``destination`` blob. :type if_metageneration_match: long :param if_metageneration_match: (Optional) See :ref:`using-if-metageneration-match` Note that the metageneration to be matched is that of the ``destination`` blob. :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) See :ref:`using-if-metageneration-not-match` Note that the metageneration to be matched is that of the ``destination`` blob. :type if_source_generation_match: long :param if_source_generation_match: (Optional) Makes the operation conditional on whether the source object's generation matches the given value. :type if_source_generation_not_match: long :param if_source_generation_not_match: (Optional) Makes the operation conditional on whether the source object's generation does not match the given value. :type if_source_metageneration_match: long :param if_source_metageneration_match: (Optional) Makes the operation conditional on whether the source object's current metageneration matches the given value. :type if_source_metageneration_not_match: long :param if_source_metageneration_not_match: (Optional) Makes the operation conditional on whether the source object's current metageneration does not match the given value. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: :class:`google.cloud.storage.blob.Blob` :returns: The new Blob. Example: Copy a blob including ACL. >>> from google.cloud import storage >>> client = storage.Client(project="project") >>> bucket = client.bucket("bucket") >>> dst_bucket = client.bucket("destination-bucket") >>> blob = bucket.blob("file.ext") >>> new_blob = bucket.copy_blob(blob, dst_bucket) >>> new_blob.acl.save(blob.acl) NrsourceGeneration)rrrrif_source_generation_matchif_source_generation_not_matchif_source_metageneration_match"if_source_metageneration_not_match)r5r3z/copyTor)rrr) rrr r3rr_post_resourcersaver6)rJr8destination_bucketnew_namer preserve_aclsource_generationrrrrrrrrrrrnew_blobapi_path copy_resultr*r*r1 copy_blobsB u      zBucket.copy_blobcCsP|j|k}|j||||| |||||| | | | d}|s&|j|| || | | | d|S)aRename the given blob using copy and delete operations. If :attr:`user_project` is set, bills the API request to that project. Effectively, copies blob to the same bucket with a new name, then deletes the blob. .. warning:: This method will first duplicate the data and then delete the old blob. This means that with very large objects renaming could be a very (temporarily) costly or a very slow operation. If you need more control over the copy and deletion, instead use `google.cloud.storage.blob.Blob.copy_to` and `google.cloud.storage.blob.Blob.delete` directly. :type blob: :class:`google.cloud.storage.blob.Blob` :param blob: The blob to be renamed. :type new_name: str :param new_name: The new name for this blob. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type if_generation_match: long :param if_generation_match: (Optional) See :ref:`using-if-generation-match` Note that the generation to be matched is that of the ``destination`` blob. :type if_generation_not_match: long :param if_generation_not_match: (Optional) See :ref:`using-if-generation-not-match` Note that the generation to be matched is that of the ``destination`` blob. :type if_metageneration_match: long :param if_metageneration_match: (Optional) See :ref:`using-if-metageneration-match` Note that the metageneration to be matched is that of the ``destination`` blob. :type if_metageneration_not_match: long :param if_metageneration_not_match: (Optional) See :ref:`using-if-metageneration-not-match` Note that the metageneration to be matched is that of the ``destination`` blob. :type if_source_generation_match: long :param if_source_generation_match: (Optional) Makes the operation conditional on whether the source object's generation matches the given value. Also used in the (implied) delete request. :type if_source_generation_not_match: long :param if_source_generation_not_match: (Optional) Makes the operation conditional on whether the source object's generation does not match the given value. Also used in the (implied) delete request. :type if_source_metageneration_match: long :param if_source_metageneration_match: (Optional) Makes the operation conditional on whether the source object's current metageneration matches the given value. Also used in the (implied) delete request. :type if_source_metageneration_not_match: long :param if_source_metageneration_not_match: (Optional) Makes the operation conditional on whether the source object's current metageneration does not match the given value. Also used in the (implied) delete request. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: :class:`Blob` :returns: The newly-renamed blob. ) rrrrrrrrrrr)rrrrrrr)r3r!r)rJr8rrrrrrrrrrrr same_namerr*r*r1 rename_blob[s8 g zBucket.rename_blobcCsdd|jddDS)aRetrieve or set CORS policies configured for this bucket. See http://www.w3.org/TR/cors/ and https://cloud.google.com/storage/docs/json_api/v1/buckets .. note:: The getter for this property returns a list which contains *copies* of the bucket's CORS policy mappings. Mutating the list or one of its dicts has no effect unless you then re-assign the dict via the setter. E.g.: >>> policies = bucket.cors >>> policies.append({'origin': '/foo', ...}) >>> policies[1]['maxAgeSeconds'] = 3600 >>> del policies[0] >>> bucket.cors = policies >>> bucket.update() :setter: Set CORS policies for this bucket. :getter: Gets the CORS policies for this bucket. :rtype: list of dictionaries :returns: A sequence of mappings describing each CORS policy. cSsg|]}t|qSr*)r r ).0policyr*r*r1 szBucket.cors..corsr*rr,rar*r*r1r'sz Bucket.corscCs|d|dS)a"Set CORS policies configured for this bucket. See http://www.w3.org/TR/cors/ and https://cloud.google.com/storage/docs/json_api/v1/buckets :type entries: list of dictionaries :param entries: A sequence of mappings describing each CORS policy. r'Nr)rJentriesr*r*r1r's defaultEventBasedHoldcCs|jdi}|dS)aRetrieve / set default KMS encryption key for objects in the bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets :setter: Set default KMS encryption key for items in this bucket. :getter: Get default KMS encryption key for items in this bucket. :rtype: str :returns: Default KMS encryption key, or ``None`` if not set. encryptiondefaultKmsKeyNamer()rJencryption_configr*r*r1default_kms_key_names zBucket.default_kms_key_namecCs&|jdi}||d<|d|dS)zSet default KMS encryption key for objects in the bucket. :type value: str or None :param value: new KMS key name (None to clear any existing key). r,r-N)rr,r)rJrr.r*r*r1r/(scCs"|jd}|dur iSt|S)aRetrieve or set labels assigned to this bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets#labels .. note:: The getter for this property returns a dict which is a *copy* of the bucket's labels. Mutating that dict has no effect unless you then re-assign the dict via the setter. E.g.: >>> labels = bucket.labels >>> labels['new_key'] = 'some-label' >>> del labels['old_key'] >>> bucket.labels = labels >>> bucket.update() :setter: Set labels for this bucket. :getter: Gets the labels for this bucket. :rtype: :class:`dict` :returns: Name-value pairs (string->string) labelling the bucket. rNrr,r r )rJrr*r*r1r3s  z Bucket.labelscCsjtdd|jD}tdd|D}|j|||_dd|D}|dt |dS)zSet labels assigned to this bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets#labels :type mapping: :class:`dict` :param mapping: Name-value pairs (string->string) labelling the bucket. cSg|]}|qSr*r*r$kr*r*r1r&]z!Bucket.labels..cSr1r*r*r2r*r*r1r&^r4cSsi|] \}}|t|qSr*)str)r$r3vr*r*r1 `sz!Bucket.labels..rN) rrkeysrunion differenceitemsrr r )rJmappingexistingincomingr*r*r1rQs  cC |jdS)aVRetrieve the ETag for the bucket. See https://tools.ietf.org/html/rfc2616#section-3.11 and https://cloud.google.com/storage/docs/json_api/v1/buckets :rtype: str or ``NoneType`` :returns: The bucket etag or ``None`` if the bucket's resource has not been loaded from the server. etagr(rar*r*r1r@es z Bucket.etagcCr?)aRetrieve the ID for the bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets :rtype: str or ``NoneType`` :returns: The ID of the bucket or ``None`` if the bucket's resource has not been loaded from the server. idr(rar*r*r1rAr z Bucket.idcCs|jdi}t||S)zRetrieve IAM configuration for this bucket. :rtype: :class:`IAMConfiguration` :returns: an instance for managing the bucket's IAM configuration. r)rr,rr:rJinfor*r*r1iam_configuration~s zBucket.iam_configurationccst|jdi}|ddD])}|dd}|dkr!t|Vq|dkr,t|Vqtjd|td d qd S) aRetrieve or set lifecycle rules configured for this bucket. See https://cloud.google.com/storage/docs/lifecycle and https://cloud.google.com/storage/docs/json_api/v1/buckets .. note:: The getter for this property returns a list which contains *copies* of the bucket's lifecycle rules mappings. Mutating the list or one of its dicts has no effect unless you then re-assign the dict via the setter. E.g.: >>> rules = bucket.lifecycle_rules >>> rules.append({'origin': '/foo', ...}) >>> rules[1]['rule']['action']['type'] = 'Delete' >>> del rules[0] >>> bucket.lifecycle_rules = rules >>> bucket.update() :setter: Set lifestyle rules for this bucket. :getter: Gets the lifestyle rules for this bucket. :rtype: generator(dict) :returns: A sequence of mappings describing each lifecycle rule. lifecycleryr*rurrrsr}zgUnknown lifecycle rule type received: {}. Please upgrade to the latest version of google-cloud-storage.rrN) rr,rqr:r|rrformat UserWarning)rJrDry action_typer*r*r1lifecycle_ruless  zBucket.lifecycle_rulescCs"dd|D}|dd|idS)a8Set lifestyle rules configured for this bucket. See https://cloud.google.com/storage/docs/lifecycle and https://cloud.google.com/storage/docs/json_api/v1/buckets :type rules: list of dictionaries :param rules: A sequence of mappings describing each lifecycle rule. cSsg|]}t|qSr*)rw)r$ryr*r*r1r&sz*Bucket.lifecycle_rules..rFryNr))rJrulesr*r*r1rJs cCs g|_dS)zSet lifestyle rules configured for this bucket. See https://cloud.google.com/storage/docs/lifecycle and https://cloud.google.com/storage/docs/json_api/v1/buckets N)rJrar*r*r1clear_lifecyle_ruless zBucket.clear_lifecyle_rulescKs(t|j}|tdi|||_dS)aAdd a "delete" rule to lifestyle rules configured for this bucket. See https://cloud.google.com/storage/docs/lifecycle and https://cloud.google.com/storage/docs/json_api/v1/buckets .. literalinclude:: snippets.py :start-after: [START add_lifecycle_delete_rule] :end-before: [END add_lifecycle_delete_rule] :dedent: 4 :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. Nr*)rrJappendrq)rJrxrKr*r*r1add_lifecycle_delete_rules  z Bucket.add_lifecycle_delete_rulecKs*t|j}|t|fi|||_dS)aAdd a "delete" rule to lifestyle rules configured for this bucket. See https://cloud.google.com/storage/docs/lifecycle and https://cloud.google.com/storage/docs/json_api/v1/buckets .. literalinclude:: snippets.py :start-after: [START add_lifecycle_set_storage_class_rule] :end-before: [END add_lifecycle_set_storage_class_rule] :dedent: 4 :type storage_class: str, one of :attr:`STORAGE_CLASSES`. :param storage_class: new storage class to assign to matching items. :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. N)rrJrMr|)rJrrxrKr*r*r1$add_lifecycle_set_storage_class_rules  z+Bucket.add_lifecycle_set_storage_class_rulercCr)ayRetrieve location configured for this bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets and https://cloud.google.com/storage/docs/bucket-locations Returns ``None`` if the property has not been set before creation, or if the bucket's resource has not been loaded from the server. :rtype: str or ``NoneType`` ) _locationrar*r*r1rs zBucket.locationcCstjttdd||_dS)a(Deprecated) Set `Bucket.location` This can only be set at bucket **creation** time. See https://cloud.google.com/storage/docs/json_api/v1/buckets and https://cloud.google.com/storage/docs/bucket-locations .. warning:: Assignment to 'Bucket.location' is deprecated, as it is only valid before the bucket is created. Instead, pass the location to `Bucket.create`. rrN)rr_LOCATION_SETTER_MESSAGErrPrr*r*r1rs cCr?)aLRetrieve or set the location type for the bucket. See https://cloud.google.com/storage/docs/storage-classes :setter: Set the location type for this bucket. :getter: Gets the the location type for this bucket. :rtype: str or ``NoneType`` :returns: If set, one of :attr:`~google.cloud.storage.constants.MULTI_REGION_LOCATION_TYPE`, :attr:`~google.cloud.storage.constants.REGION_LOCATION_TYPE`, or :attr:`~google.cloud.storage.constants.DUAL_REGION_LOCATION_TYPE`, else ``None``. locationTyper(rar*r*r1 location_type s zBucket.location_typecCs|jd}t|S)a#Return info about access logging for this bucket. See https://cloud.google.com/storage/docs/access-logs#status :rtype: dict or None :returns: a dict w/ keys, ``logBucket`` and ``logObjectPrefix`` (if logging is enabled), or None (if not). loggingr0rCr*r*r1 get_logging# s zBucket.get_loggingcC||d}|d|dS)a7Enable access logging for this bucket. See https://cloud.google.com/storage/docs/access-logs :type bucket_name: str :param bucket_name: name of bucket in which to store access logs :type object_prefix: str :param object_prefix: prefix for access log filenames ) logBucketlogObjectPrefixrTNr))rJr object_prefixrDr*r*r1enable_logging/ s zBucket.enable_loggingcCs|dddS)zyDisable access logging for this bucket. See https://cloud.google.com/storage/docs/access-logs#disabling rTNr)rar*r*r1disable_logging= szBucket.disable_loggingcC |jd}|durt|SdS)a/Retrieve the metageneration for the bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets :rtype: int or ``NoneType`` :returns: The metageneration of the bucket or ``None`` if the bucket's resource has not been loaded from the server. metagenerationNrr,int)rJr^r*r*r1r^D  zBucket.metagenerationcCst|jdS)a1Retrieve info about the owner of the bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets :rtype: dict or ``NoneType`` :returns: Mapping of owner's role/ID. Returns ``None`` if the bucket's resource has not been loaded from the server. owner)r r rr,rar*r*r1rbR s z Bucket.ownercCr])aNRetrieve the number of the project to which the bucket is assigned. See https://cloud.google.com/storage/docs/json_api/v1/buckets :rtype: int or ``NoneType`` :returns: The project number that owns the bucket or ``None`` if the bucket's resource has not been loaded from the server. projectNumberNr_)rJproject_numberr*r*r1rd^ razBucket.project_numbercC6|jd}|dur|d}|durt|SdSdS)a"Retrieve the effective time of the bucket's retention policy. :rtype: datetime.datetime or ``NoneType`` :returns: point-in time at which the bucket's retention policy is effective, or ``None`` if the property is not set locally. retentionPolicyN effectiveTimerr,r)rJr% timestampr*r*r1retention_policy_effective_timel   z&Bucket.retention_policy_effective_timecCs"|jd}|dur|dSdS)aRetrieve whthere the bucket's retention policy is locked. :rtype: bool :returns: True if the bucket's policy is locked, or else False if the policy is not locked, or the property is not set locally. rfNisLockedr()rJr%r*r*r1retention_policy_locked{ s  zBucket.retention_policy_lockedcCre)a"Retrieve or set the retention period for items in the bucket. :rtype: int or ``NoneType`` :returns: number of seconds to retain items after upload or release from event-based lock, or ``None`` if the property is not set locally. rfNretentionPeriodr_)rJr%periodr*r*r1retention_period rkzBucket.retention_periodcCs8|jdi}|durt||d<nd}|d|dS)aSet the retention period for items in the bucket. :type value: int :param value: number of seconds to retain items after upload or release from event-based lock. :raises ValueError: if the bucket's retention policy is locked. rfNrn)rrr5r)rJrr%r*r*r1rp s  cCr?)a Retrieve the URI for the bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets :rtype: str or ``NoneType`` :returns: The self link for the bucket or ``None`` if the bucket's resource has not been loaded from the server. selfLinkr(rar*r*r1 self_link rBzBucket.self_linkcCr?)aRetrieve or set the storage class for the bucket. See https://cloud.google.com/storage/docs/storage-classes :setter: Set the storage class for this bucket. :getter: Gets the the storage class for this bucket. :rtype: str or ``NoneType`` :returns: If set, one of :attr:`~google.cloud.storage.constants.NEARLINE_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.COLDLINE_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.ARCHIVE_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.STANDARD_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.MULTI_REGIONAL_LEGACY_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.REGIONAL_LEGACY_STORAGE_CLASS`, or :attr:`~google.cloud.storage.constants.DURABLE_REDUCED_AVAILABILITY_LEGACY_STORAGE_CLASS`, else ``None``. r~r(rar*r*r1r s zBucket.storage_classcCs(||jvr td|f|d|dS)aSet the storage class for the bucket. See https://cloud.google.com/storage/docs/storage-classes :type value: str :param value: One of :attr:`~google.cloud.storage.constants.NEARLINE_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.COLDLINE_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.ARCHIVE_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.STANDARD_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.MULTI_REGIONAL_LEGACY_STORAGE_CLASS`, :attr:`~google.cloud.storage.constants.REGIONAL_LEGACY_STORAGE_CLASS`, or :attr:`~google.cloud.storage.constants.DURABLE_REDUCED_AVAILABILITY_LEGACY_STORAGE_CLASS`, zInvalid storage class: %sr~N)STORAGE_CLASSESrGrrr*r*r1r s cCr])axRetrieve the timestamp at which the bucket was created. See https://cloud.google.com/storage/docs/json_api/v1/buckets :rtype: :class:`datetime.datetime` or ``NoneType`` :returns: Datetime object parsed from RFC3339 valid timestamp, or ``None`` if the bucket's resource has not been loaded from the server. timeCreatedNrhrr*r*r1 time_created s zBucket.time_createdcC|jdi}|ddS)a]Is versioning enabled for this bucket? See https://cloud.google.com/storage/docs/object-versioning for details. :setter: Update whether versioning is enabled for this bucket. :getter: Query whether versioning is enabled for this bucket. :rtype: bool :returns: True if enabled, else False. versioningrFr(rJrwr*r*r1versioning_enabled s zBucket.versioning_enabledcC|ddt|idS)zEnable versioning for this bucket. See https://cloud.google.com/storage/docs/object-versioning for details. :type value: convertible to boolean :param value: should versioning be enabled for the bucket? rwrNrrrr*r*r1ry  cCrv)aDoes the requester pay for API requests for this bucket? See https://cloud.google.com/storage/docs/requester-pays for details. :setter: Update whether requester pays for this bucket. :getter: Query whether requester pays for this bucket. :rtype: bool :returns: True if requester pays for API requests for the bucket, else False. billing requesterPaysFr(rxr*r*r1requester_pays s zBucket.requester_payscCrz)aUpdate whether requester pays for API requests for this bucket. See https://cloud.google.com/storage/docs/using-requester-pays for details. :type value: convertible to boolean :param value: should requester pay for API requests for the bucket? r}r~Nr{rr*r*r1r r|cCrW)aConfigure website-related properties. See https://cloud.google.com/storage/docs/hosting-static-website .. note:: This (apparently) only works if your bucket name is a domain name (and to do that, you need to get approved somehow...). If you want this bucket to host a website, just provide the name of an index page and a page to use when a blob isn't found: .. literalinclude:: snippets.py :start-after: [START configure_website] :end-before: [END configure_website] :dedent: 4 You probably should also make the whole bucket public: .. literalinclude:: snippets.py :start-after: [START make_public] :end-before: [END make_public] :dedent: 4 This says: "Make the bucket public, and all the stuff already in the bucket, and anything else I add to the bucket. Just make it all public." :type main_page_suffix: str :param main_page_suffix: The page to use as the main page of a directory. Typically something like index.html. :type not_found_page: str :param not_found_page: The file to use when a page isn't found. )mainPageSuffix notFoundPagewebsiteNr))rJmain_page_suffixnot_found_pagerr*r*r1configure_website+ s %zBucket.configure_websitecCs |ddS)zDisable the website configuration for this bucket. This is really just a shortcut for setting the website-related attributes to ``None``. N)rrar*r*r1disable_websiteS s zBucket.disable_websitecCsX||}i}|jdur|j|d<|dur||d<|jd|jf|||dd}t|S)a Retrieve the IAM policy for the bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets/getIamPolicy If :attr:`user_project` is set, bills the API request to that project. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type requested_policy_version: int or ``NoneType`` :param requested_policy_version: (Optional) The version of IAM policies to request. If a policy with a condition is requested without setting this, the server will return an error. This must be set to a value of 3 to retrieve IAM policies containing conditions. This is to prevent client code that isn't aware of IAM conditions from interpreting and modifying policies incorrectly. The service might return a policy with version lower than the one that was requested, based on the feature syntax in the policy fetched. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: :class:`google.api_core.iam.Policy` :returns: the policy instance, based on the resource returned from the ``getIamPolicy`` API request. Example: .. code-block:: python from google.cloud.storage.iam import STORAGE_OBJECT_VIEWER_ROLE policy = bucket.get_iam_policy(requested_policy_version=3) policy.version = 3 # Add a binding to the policy via it's bindings property policy.bindings.append({ "role": STORAGE_OBJECT_VIEWER_ROLE, "members": {"serviceAccount:account@project.iam.gserviceaccount.com", ...}, # Optional: "condition": { "title": "prefix" "description": "Objects matching prefix" "expression": "resource.name.startsWith("projects/project-name/buckets/bucket-name/objects/prefix")" } }) bucket.set_iam_policy(policy) NroptionsRequestedPolicyVersionz%s/iamr)rrrrrr:)rJrrequested_policy_versionrrrrDr*r*r1get_iam_policy[ s D    zBucket.get_iam_policyc Cs`||}i}|jdur|j|d<d|j}|}|j|d<|j|||||dd}t|S)aUpdate the IAM policy for the bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets/setIamPolicy If :attr:`user_project` is set, bills the API request to that project. :type policy: :class:`google.api_core.iam.Policy` :param policy: policy instance used to update bucket's IAM policy. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: :class:`google.api_core.iam.Policy` :returns: the policy instance, based on the resource returned from the ``setIamPolicy`` API request. Nrz{}/iam resourceIdr)rrrGr to_api_repr _put_resourcerr:) rJr%rrrrrr\rDr*r*r1set_iam_policy s #     zBucket.set_iam_policycCsR||}d|i}|jdur|j|d<d|jf}|j||||dd}|dgS)aNAPI call: test permissions See https://cloud.google.com/storage/docs/json_api/v1/buckets/testIamPermissions If :attr:`user_project` is set, bills the API request to that project. :type permissions: list of string :param permissions: the permissions to check :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :rtype: list of string :returns: the permissions returned by the ``testIamPermissions`` API request. permissionsNrz%s/iam/testPermissionsr)rrrrr,)rJrrrrrrrespr*r*r1test_iam_permissions s     zBucket.test_iam_permissionsc C|j|jj||d|r+|j}|js|j||d||j||d|r`t|jd|j d||d}t ||j krLd|j f}t ||D]}|j|jj||dqNdSdS)aUpdate bucket's ACL, granting read access to anonymous users. :type recursive: bool :param recursive: If True, this will make all blobs inside the bucket public as well. :type future: bool :param future: If True, this will make all objects created in the future public as well. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :raises ValueError: If ``recursive`` is True, and the bucket contains more than 256 blobs. This is to prevent extremely long runtime of this method. For such buckets, iterate over the blobs returned by :meth:`list_blobs` and call :meth:`~google.cloud.storage.blob.Blob.make_public` for each blob. rrfullrrrrrzRefusing to make public recursively with more than %d objects. If you actually want to make every object in this bucket public, iterate through the blobs returned by 'Bucket.list_blobs()' and call 'make_public' on each one.N) rall grant_readrrloadedrrrrrrG rJ recursivefuturerrdoarrr8r*r*r1 make_public s6 zBucket.make_publicc Cr)aUpdate bucket's ACL, revoking read access for anonymous users. :type recursive: bool :param recursive: If True, this will make all blobs inside the bucket private as well. :type future: bool :param future: If True, this will make all objects created in the future private as well. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :raises ValueError: If ``recursive`` is True, and the bucket contains more than 256 blobs. This is to prevent extremely long runtime of this method. For such buckets, iterate over the blobs returned by :meth:`list_blobs` and call :meth:`~google.cloud.storage.blob.Blob.make_private` for each blob. rrrrzRefusing to make private recursively with more than %d objects. If you actually want to make every object in this bucket private, iterate through the blobs returned by 'Bucket.list_blobs()' and call 'make_private' on each one.N) rr revoke_readrrrrrrrrrGrr*r*r1 make_privateW s6 zBucket.make_privatec Cs||}|j}t||durttjdd}|d|jig}t||d}t t | d}t ||}|j|j|d|dd}|S)aWCreate a signed upload policy for uploading objects. This method generates and signs a policy document. You can use `policy documents`_ to allow visitors to a website to upload files to Google Cloud Storage without giving them direct write access. For example: .. literalinclude:: snippets.py :start-after: [START policy_document] :end-before: [END policy_document] :dedent: 4 .. _policy documents: https://cloud.google.com/storage/docs/xml-api /post-object#policydocument :type expiration: datetime :param expiration: (Optional) Expiration in UTC. If not specified, the policy will expire in 1 hour. :type conditions: list :param conditions: A list of conditions as described in the `policy documents`_ documentation. :type client: :class:`~google.cloud.storage.client.Client` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the current bucket. :rtype: dict :returns: A dictionary of (form field name, form field value) of form fields that should be added to your HTML upload form in order to attach the signature. Nr)hoursr5) expirationrTzutf-8)r5GoogleAccessIdr% signature)r _credentialsr ensure_signed_credentialsrdatetime timedeltar3rbase64 b64encodejsondumpsencode sign_bytes signer_emaildecode) rJrTrr credentialspolicy_documentencoded_policy_documentrrr*r*r1generate_upload_policy s& # zBucket.generate_upload_policycCsd|jvr td|jd}|durtd|dr td||}d|ji}|jdur4|j|d<d |j}|j|d||||d }| |dS) aLock the bucket's retention policy. :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the blob's bucket. :type timeout: float or tuple :param timeout: (Optional) The amount of time, in seconds, to wait for the server response. See: :ref:`configuring_timeouts` :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy :param retry: (Optional) How to retry the RPC. See: :ref:`configuring_retries` :raises ValueError: if the bucket has no metageneration (i.e., new or never reloaded); if the bucket has no retention policy assigned; if the bucket's retention policy is already locked. r^z6Bucket has no retention policy assigned: try 'reload'?rfNrlz,Bucket's retention policy is already locked.ifMetagenerationMatchrz/b/{}/lockRetentionPolicyr) rrGr,rr^rrGr3rr6)rJrrrr%rr api_responser*r*r1lock_retention_policy s*        zBucket.lock_retention_policyGEThttpc  Cs|durd}n|dvrtd| rdj|jd}n| r!t| | }ndj|jd} | s,| r.d} |dur:||}|j}|dkrAt} nt} | || |||||d S) aFGenerates a signed URL for this bucket. .. note:: If you are on Google Compute Engine, you can't generate a signed URL using GCE service account. Follow `Issue 50`_ for updates on this. If you'd like to be able to generate a signed URL from GCE, you can use a standard service account from a JSON file rather than a GCE service account. .. _Issue 50: https://github.com/GoogleCloudPlatform/ google-auth-library-python/issues/50 If you have a bucket that you want to allow access to for a set amount of time, you can use this method to generate a URL that is only valid within a certain time period. If ``bucket_bound_hostname`` is set as an argument of :attr:`api_access_endpoint`, ``https`` works only if using a ``CDN``. Example: Generates a signed URL for this bucket using bucket_bound_hostname and scheme. >>> from google.cloud import storage >>> client = storage.Client() >>> bucket = client.get_bucket('my-bucket-name') >>> url = bucket.generate_signed_url(expiration='url-expiration-time', bucket_bound_hostname='mydomain.tld', >>> version='v4') >>> url = bucket.generate_signed_url(expiration='url-expiration-time', bucket_bound_hostname='mydomain.tld', >>> version='v4',scheme='https') # If using ``CDN`` This is particularly useful if you don't want publicly accessible buckets, but don't want to require users to explicitly log in. :type expiration: Union[Integer, datetime.datetime, datetime.timedelta] :param expiration: Point in time when the signed URL should expire. If a ``datetime`` instance is passed without an explicit ``tzinfo`` set, it will be assumed to be ``UTC``. :type api_access_endpoint: str :param api_access_endpoint: (Optional) URI base. :type method: str :param method: The HTTP verb that will be used when requesting the URL. :type headers: dict :param headers: (Optional) Additional HTTP headers to be included as part of the signed URLs. See: https://cloud.google.com/storage/docs/xml-api/reference-headers Requests using the signed URL *must* pass the specified header (name and value) with each request for the URL. :type query_parameters: dict :param query_parameters: (Optional) Additional query parameters to be included as part of the signed URLs. See: https://cloud.google.com/storage/docs/xml-api/reference-headers#query :type client: :class:`~google.cloud.storage.client.Client` or ``NoneType`` :param client: (Optional) The client to use. If not passed, falls back to the ``client`` stored on the blob's bucket. :type credentials: :class:`google.auth.credentials.Credentials` or :class:`NoneType` :param credentials: The authorization credentials to attach to requests. These credentials identify this application to the service. If none are specified, the client will attempt to ascertain the credentials from the environment. :type version: str :param version: (Optional) The version of signed credential to create. Must be one of 'v2' | 'v4'. :type virtual_hosted_style: bool :param virtual_hosted_style: (Optional) If true, then construct the URL relative the bucket's virtual hostname, e.g., '.storage.googleapis.com'. :type bucket_bound_hostname: str :param bucket_bound_hostname: (Optional) If pass, then construct the URL relative to the bucket-bound hostname. Value cane be a bare or with scheme, e.g., 'example.com' or 'http://example.com'. See: https://cloud.google.com/storage/docs/request-endpoints#cname :type scheme: str :param scheme: (Optional) If ``bucket_bound_hostname`` is passed as a bare hostname, use this value as the scheme. ``https`` will work only when using a CDN. Defaults to ``"http"``. :raises: :exc:`ValueError` when version is invalid. :raises: :exc:`TypeError` when expiration is not a valid type. :raises: :exc:`AttributeError` if credentials is not an instance of :class:`google.auth.credentials.Signing`. :rtype: str :returns: A signed URL you can use to access the resource until expiration. Nv2)rv4z%'version' must be either 'v2' or 'v4'z,https://{bucket_name}.storage.googleapis.comrz/{bucket_name}/)r\rapi_access_endpointmethodrquery_parameters) rGrGr3rrrrrupper)rJrrrrrrrversionvirtual_hosted_stylebucket_bound_hostnamerr\helperr*r*r1generate_signed_url s<u zBucket.generate_signed_url)NNr)NNNN)rV)^rirjrkrlrr!rrrrrrrsrr r_LOCATION_TYPESrIrrnrr6rrmrr8r$rrr%rrr(r-rrrr staticmethodrrrrrrrr&r rr!r#r'rr default_event_based_holdr/rr@rArErJrLrNrOrPrrSrUr[r\r^rbrdrjrmrprrrruryrrrrr'rrrrrr_API_ACCESS_ENDPOINTrror*r*rUr1r/s        0  V O.?5      q | % 0 j b t #            *                      (  Y 9 0 @ @@ 7rcKs8|D]\}}|durt||krtd|qdS)a Raise an error if any generation match argument is set and its len differs from the given value. :type expected_len: int :param expected_len: Expected argument length in case it's set. :type generation_match_args: dict :param generation_match_args: Lists, which length must be checked. :raises: :exc:`ValueError` if any argument set, but has an unexpected length. Nz.'{}' length must be the same as 'blobs' length)r;rrGrG) expected_lengeneration_match_argsr3rr*r*r1r  s r )Krlrr rrrrsix.moves.urllib.parsergoogle.api_corergoogle.cloud._helpersrrrgoogle.cloud.exceptionsrgoogle.api_core.iamrgoogle.cloud.storager google.cloud.storage._helpersr r r r rgoogle.cloud.storage._signingrrrgoogle.cloud.storage.aclrrgoogle.cloud.storage.blobrgoogle.cloud.storage.constantsrrrrrrrrrrr r!!google.cloud.storage.notificationr#r$google.cloud.storage.retryr%r&r'r(rrrrrQrr2r9r;rwr<rqr|objectrrrr r*r*r*r1s                                     *"2