a !fp@sdZddlZddlZddlZddlZddlmZddlZddlm Z ddl m Z ddl m Z ddl m Z ddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlm 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#m/Z/dd"l0m1Z1dd#l0m2Z2dd$l3m4Z4dd%l3m5Z5dd&l3m6Z6dd'l3m7Z7d(Z8d)Z9d*Z:d+Z;d,Zd0d1Z?d2d3Z@Gd4d5d5eAZBGd6d7d7eAZCGd8d9d9eAZDGd:d;d;eAZEeFZGGdd?d?eZId@dAZJdS)Bz4Create / 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_INHERITED)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*\/var/www/html/python-backend/venv/lib/python3.9/site-packages/google/cloud/storage/bucket.py_blobs_page_startXs 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_blobhs  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;c seZdZdZdfdd ZeddZedd Zed d Z ed d Z eddZ eddZ eddZ eddZeddZeddZeddZeddZZS)LifecycleRuleConditionsaE 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_prefix: list(str) :param matches_prefix: (Optional) Apply rule action to items which any prefix matches the beginning of the item name. :type matches_storage_class: list(str), one or more of :attr:`Bucket.STORAGE_CLASSES`. :param matches_storage_class: (Optional) Apply rule action to items whose storage class matches this value. :type matches_suffix: list(str) :param matches_suffix: (Optional) Apply rule action to items which any suffix matches the end of the item name. :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<|dur8|| d<|durH|| d<|durX|| d<|durh|| d<|dur||| d<|dur|| d<| dur| | d <| dur| | d <| dur| | d <| s| std tt|| dS) Nage createdBeforeisLivematchesStorageClassnumNewerVersionsdaysSinceCustomTimecustomTimeBeforedaysSinceNoncurrentTimenoncurrentTimeBefore matchesPrefix matchesSuffixzSupply at least one condition) isoformat ValueErrorsuperr<__init__)selfr=created_beforeis_livematches_storage_classnumber_of_newer_versionsdays_since_custom_timecustom_time_beforedays_since_noncurrent_timenoncurrent_time_beforematches_prefixmatches_suffix_factory conditions __class__r*r1rKs4   z LifecycleRuleConditions.__init__cCs|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. TrWr-clsresourceinstancer*r*r1r: s  z%LifecycleRuleConditions.from_api_reprcCs |dS)zConditon's age value.r=r,rLr*r*r1r=szLifecycleRuleConditions.agecCs |d}|durt|SdS)z Conditon's created_before value.r>Nr,rZfrom_iso8601_daterLbeforer*r*r1rMs z&LifecycleRuleConditions.created_beforecCs |dS)zConditon's 'is_live' value.r?rarbr*r*r1rN$szLifecycleRuleConditions.is_livecCs |dS)z"Conditon's 'matches_prefix' value.rFrarbr*r*r1rU)sz&LifecycleRuleConditions.matches_prefixcCs |dS)z)Conditon's 'matches_storage_class' value.r@rarbr*r*r1rO.sz-LifecycleRuleConditions.matches_storage_classcCs |dS)z"Conditon's 'matches_suffix' value.rGrarbr*r*r1rV3sz&LifecycleRuleConditions.matches_suffixcCs |dS)z,Conditon's 'number_of_newer_versions' value.rArarbr*r*r1rP8sz0LifecycleRuleConditions.number_of_newer_versionscCs |dS)z*Conditon's 'days_since_custom_time' value.rBrarbr*r*r1rQ=sz.LifecycleRuleConditions.days_since_custom_timecCs |d}|durt|SdS)z&Conditon's 'custom_time_before' value.rCNrcrdr*r*r1rRBs z*LifecycleRuleConditions.custom_time_beforecCs |dS)z.Conditon's 'days_since_noncurrent_time' value.rDrarbr*r*r1rSIsz2LifecycleRuleConditions.days_since_noncurrent_timecCs |d}|durt|SdS)z*Conditon's 'noncurrent_time_before' value.rENrcrdr*r*r1rTNs z.LifecycleRuleConditions.noncurrent_time_before) NNNNNNNNNNNF)__name__ __module__ __qualname____doc__rK classmethodr:propertyr=rMrNrUrOrVrPrQrRrSrT __classcell__r*r*rYr1r<sLA7           r<cs,eZdZdZfddZeddZZS)LifecycleRuleDeletezMap a lifecycle rule deleting matching items. :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. c s0tfi|}ddit|d}t|dS)NtypeDeleteaction conditionr<dictrJrKrLkwrXrulerYr*r1rK]szLifecycleRuleDelete.__init__cCs|dd}|||S)zFactory: construct instance from resource. :type resource: dict :param resource: mapping as returned from API call. :rtype: :class:`LifecycleRuleDelete` :returns: Instance created from resource. Tr[r\r]r*r*r1r:bs  z!LifecycleRuleDelete.from_api_reprrfrgrhrirKrjr:rlr*r*rYr1rmVs rmcs,eZdZdZfddZeddZZS)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 s2tfi|}d|dt|d}t|dS)NSetStorageClass)rn storageClassrprs)rL storage_classrvrXrwrYr*r1rK{s z%LifecycleRuleSetStorageClass.__init__cCs&|d}||ddd}|||S)zFactory: construct instance from resource. :type resource: dict :param resource: mapping as returned from API call. :rtype: :class:`LifecycleRuleSetStorageClass` :returns: Instance created from resource. rqr{Tr[r\)r^r_rqr`r*r*r1r:s  z*LifecycleRuleSetStorageClass.from_api_reprrxr*r*rYr1ryqs rycs,eZdZdZfddZeddZZS)+LifecycleRuleAbortIncompleteMultipartUploadzMap a rule aborting incomplete multipart uploads of matching items. The "age" lifecycle condition is the only supported condition for this rule. :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. c s0tfi|}ddit|d}t|dS)NrnAbortIncompleteMultipartUploadrprsrurYr*r1rKs z4LifecycleRuleAbortIncompleteMultipartUpload.__init__cCs|dd}|||S)aFactory: construct instance from resource. :type resource: dict :param resource: mapping as returned from API call. :rtype: :class:`LifecycleRuleAbortIncompleteMultipartUpload` :returns: Instance created from resource. Tr[r\r]r*r*r1r:s  z9LifecycleRuleAbortIncompleteMultipartUpload.from_api_reprrxr*r*rYr1r}s 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 'inherited' (default) or 'enforced' 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,|turtttjttdd|}|turX|turDtttjttdd|}|turdd}|turpt }d|i|d}|turt ||dd<t t | |||_dS)N stacklevelFenabled)uniformBucketLevelAccesspublicAccessPreventionr lockedTime)_defaultrI_UBLA_BPO_ENABLED_MESSAGEwarningswarn_BPO_ENABLED_MESSAGEDeprecationWarning_UBLA_BPO_LOCK_TIME_MESSAGE_BPO_LOCK_TIME_MESSAGErrrJrrK_bucket)rLr5public_access_prevention#uniform_bucket_level_access_enabled'uniform_bucket_level_access_locked_timebucket_policy_only_enabledbucket_policy_only_locked_timedatarYr*r1rKs0  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. r\)r^r_r5r`r*r*r1r:s  zIAMConfiguration.from_api_reprcCs|jS)zBucket for which this instance is the policy. :rtype: :class:`Bucket` :returns: the instance's bucket. )rrbr*r*r1r5szIAMConfiguration.bucketcCs|dS)a(Setting for public access prevention policy. Options are 'inherited' (default) or 'enforced'. See: https://cloud.google.com/storage/docs/public-access-prevention :rtype: string :returns: the public access prevention status, either 'enforced' or 'inherited'. rr*rbr*r*r1rs z)IAMConfiguration.public_access_preventioncCs||d<|jd|dS)NriamConfiguration)r5_patch_propertyrLvaluer*r*r1r$scCs|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. rrFra)rLublar*r*r1r)s z4IAMConfiguration.uniform_bucket_level_access_enabledcCs*|di}t||d<|jd|dS)Nrrr) setdefaultboolr5r)rLrrr*r*r1r3s  cCs*|di}|d}|dur&t|}|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)rLrZstampr*r*r1r9s   z8IAMConfiguration.uniform_bucket_level_access_locked_timecCs|jS)zDeprecated alias for :attr:`uniform_bucket_level_access_enabled`. :rtype: bool :returns: whether the bucket is configured to allow only IAM. )rrbr*r*r1rMsz+IAMConfiguration.bucket_policy_only_enabledcCstjttdd||_dS)Nrr)rrrrrrr*r*r1rVscCs|jS)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. )rrbr*r*r1r[s z/IAMConfiguration.bucket_policy_only_locked_time)rfrgrhrirrKrjr:rkr5rsetterrrrrrlr*r*rYr1rs6,         rcseZdZdZdZeeeee e e fZ e eefZdfdd ZddZedd Zfd d Zed d Zejdd ZeddZedddZdddZdddddedfddZdeddddefddZ dddddeefddZ!dedde"ffdd Z#ddeddddeffdd Z$dedde"ffd d! Z%ed"d#Z&ed$d%Z'e(d&d'Z)ed(d)Z*dddddddddeef d*d+Z+dddddddddddeef d,d-Z,deefd.d/Z-deefd0d1Z.d2dddeefd3d4Z/ddddddee0fd5d6Z1ddd2edddde0f d7d8Z2ddd9dddddddddee0fd:d;Z3dddddddddee0f dd?Z5e5jd@d?Z5e6dAZ7edBdCZ8e8jdDdCZ8edEdFZ9e9jdGdFZ9edHdIZ:edJdKZ;edLdMZdSdTZ?dUdVZ@dWdXZAe6dYZBedZd[ZCeCjd\d[ZCed]d^ZDed_d`ZEdadbZFddddeZGdfdgZHedhdiZIedjdkZJedldmZKedndoZLedpdqZMedrdsZNeNjdtdsZNedudvZOedwdxZPePjdydxZPedzd{ZQed|d}ZReRjd~d}ZReddZSeSjddZSeddZTeTjddZTeddZUdddZVddZWddeefddZXdeeYfddZZdeefddZ[d2d2dedde"fddZ\d2d2dedde"fddZ]dddZ^deefddZ_de`ddddddd2ddf ddZaZbS)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) rrJrrK_clientr_aclr_default_object_aclset_label_removals _user_project)rLclientr3 user_projectrYr*r1rKs  zBucket.__init__cCsd|jdS)Nz rrbr*r*r1__repr__szBucket.__repr__cCs|jS)z The client bound to this bucket.)rrbr*r*r1rsz 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. )rclearrJrr6rrYr*r1r6s zBucket._set_propertiescCs |jdS)zGet the RPO (Recovery Point Objective) of this bucket See: https://cloud.google.com/storage/docs/managing-turbo-replication "ASYNC_TURBO" or "DEFAULT" :rtype: str rpo _propertiesr,rbr*r*r1rs z Bucket.rpocCs|d|dS)z Set the RPO (Recovery Point Objective) of this bucket. See: https://cloud.google.com/storage/docs/managing-turbo-replication :type value: str :param value: "ASYNC_TURBO" or "DEFAULT" rNrrr*r*r1rs cCs|jS)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 )rrbr*r*r1rs zBucket.user_projectcCs.t|\}}}}}|dkr"td|||dS)aGet a constructor for bucket object by URI. .. code-block:: python from google.cloud import storage from google.cloud.storage.bucket import Bucket client = storage.Client() bucket = Bucket.from_string("gs://bucket", client=client) :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. Application code should *always* pass ``client``. :rtype: :class:`google.cloud.storage.bucket.Bucket` :returns: The bucket object created. gszURI scheme must be gsr)rrI)r^urirschemenetlocpathqueryfragr*r*r1 from_stringszBucket.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)rL 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")rLrrrrrrrr*r*r1 notification$szBucket.notificationc Cs|||}ddi}|jdur&|j|d<t|||di} t| ||dz|j|j|| ||ddWntyvYdS0d S) 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) rLrrrrrrrrrr*r*r1exists?s2/     z Bucket.existsc Cs*||}|j|||j|||||ddS)aCreates current bucket. 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` )Zbucket_or_nameprojectrlocationpredefined_aclpredefined_default_object_aclrrN)rZ create_bucketr)rLrrrrrrrr*r*r1creates8 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)rJrr-)rLrrrrrrYr*r1r-s$ z Bucket.updateZnoAclc 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)rJrreload) rLrrrrrrrrrYr*r1rs2 z Bucket.reloadcsX|jr:|jd|jdi|jD]}d|jd|<q&tt|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)rZ_changesaddrrrJrpatch)rLrrrrrZ removed_labelrYr*r1r@s&   z Bucket.patchcCs|jS)zCreate our ACL on demand.)rrbr*r*r1aclusz Bucket.aclcCs|jS)z&Create our defaultObjectACL on demand.)rrbr*r*r1default_object_aclzszBucket.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``. /b/r*) bucket_namer*r*r1 path_helpers zBucket.path_helpercCs|jstd||jS)zThe URL path to this bucket.z*Cannot determine path without bucket name.)r3rIrrbr*r*r1rsz Bucket.pathc  KsVtf||||d| }z |j|| ||||| | | d WntyLYdS0|SdS)a Get a blob object by name. See a [code sample](https://cloud.google.com/storage/docs/samples/storage-get-metadata#storage_get_metadata-python) on how to retrieve metadata of an object. 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_matchrrrN)rrr)rLrrrrrrrrrrrrkwargsr8r*r*r1get_blobs.P zBucket.get_blobcCs.|| } | j|||||||||| | | | d S)a Return an iterator used to find blobs in the bucket. 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. ) max_results page_tokenprefix delimiter start_offset end_offsetinclude_trailing_delimiterversionsrrrr)r list_blobs)rLrrrrrrrrrrrrrr*r*r1rs ^ zBucket.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)rrZ_list_resourcer;r5)rLrrrrr.r*r*r1list_notificationsms  zBucket.list_notificationscCs |j|d}|j|||d|S)aGet Pub / Sub notification for this bucket. See [API reference docs](https://cloud.google.com/storage/docs/json_api/v1/notifications/get) and a [code sample](https://cloud.google.com/storage/docs/samples/storage-print-pubsub-bucket-notification#storage_print_pubsub_bucket_notification-python). 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. )r)rrr)rr)rLrrrrrr*r*r1get_notifications! zBucket.get_notificationFc Cs||}i}|jdur"|j|d<t|||d|rt|j|jd|||d}t||jkrrd|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. Nrr)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().cSsdS)Nr*)r8r*r*r1 zBucket.delete..)on_errorrrrrrrr) rrr listr_MAX_OBJECTS_FOR_ITERATIONlenrI delete_blobs_delete_resourcer) rLforcerrrrrrblobsmessager*r*r1deletesJ6    z Bucket.deletec CsP||}t|||d} t| j} t| ||||d|j| j| || dddS)aODeletes a blob from the current bucket. 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` Raises a NotFound if the blob isn't found. To suppress the exception, use :meth:`delete_blobs` by passing a no-op ``on_error`` callback. )r5rrrrrNr)rrcopydeepcopyZ _query_paramsr rr) rLrrrrrrrrrr8rr*r*r1 delete_blobs":   zBucket.delete_blobc  Cstt||||| dt|pg}t|p*g}t|p6g}t| pBg} |D]} z^| } d} t| tsv| j} |rr| jnd} |j| || t|dt|dt|dt| d|| d WqJt y|dur|| nYqJ0qJdS)a Deletes a list of blobs from the current bucket. Uses :meth:`delete_blob` to delete each individual blob. By default, any generation information in the list of blobs is ignored, and the live versions of all blobs are deleted. Set `preserve_generation` to True if blob generation should instead be propagated from the list of blobs. 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 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 preserve_generation: bool :param preserve_generation: (Optional) Deletes only the generation specified on the blob object, instead of the live version, if set to True. Only :class:~google.cloud.storage.blob.Blob objects can have their generation set in this way. Default: False. :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). rN)rrrrrrrr) _raise_if_len_differsriter isinstancestrr3rrnextr)rLrrrZpreserve_generationrrrrrrr8rrr*r*r1rnsBL       zBucket.delete_blobsTc Cs||}i}|jdur"|j|d<|dur2||d<t|||| | | | | |d |durZ|j}t||d}|jd|j}|j|d||||d}|s|jji||d| ||S) a+Copy 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. See [API reference docs](https://cloud.google.com/storage/docs/json_api/v1/objects/copy) and a [code sample](https://cloud.google.com/storage/docs/samples/storage-copy-file#storage_copy_file-python). :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. NrZsourceGeneration)rrrrif_source_generation_matchif_source_generation_not_matchif_source_metageneration_match"if_source_metageneration_not_match)r5r3z/copyTor)rrr) rrr r3rr_post_resourcersaver6)rLr8Zdestination_bucketnew_namerZ preserve_aclZsource_generationrrrrr r r r rrrnew_blobZapi_pathZ copy_resultr*r*r1 copy_blobsBj       zBucket.copy_blobcCsP|j|k}|j||||| |||||| | | | d}|sL|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. ) rrrrrrr r r r r)rrrrrrr)r3rr)rLr8rrrrrrr r r r rrZ same_namerr*r*r1 rename_blobrs8g  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*)rr).0policyr*r*r1 rzBucket.cors..corsr*rrbr*r*r1rsz 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. rNr)rLentriesr*r*r1rs ZdefaultEventBasedHoldcCs|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)rLencryption_configr*r*r1default_kms_key_name0s 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). rrN)rr,r)rLrrr*r*r1r?scCs"|jd}|duriSt|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,rr)rLrr*r*r1rJs 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. cSsg|]}|qSr*r*rkr*r*r1rtrz!Bucket.labels..cSsg|]}|qSr*r*rr*r*r1rurcSsi|]\}}|t|qSr*)r)rrvr*r*r1 wrz!Bucket.labels..rN) rrkeysrunion differenceitemsrrr)rLmappingexistingincomingr*r*r1rhs cCs |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. etagrrbr*r*r1r)|s z Bucket.etagcCs |jdS)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. idrrbr*r*r1r*s 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:rLinfor*r*r1iam_configurationszBucket.iam_configurationccs|jdi}|ddD]h}|dd}|dkr@t|Vq|dkrVt|Vq|dkrlt|Vqtjd |t d 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 generator which yields *copies* of the bucket's lifecycle rules mappings. Mutating the output dicts has no effect unless you then re-assign the dict via the setter. E.g.: >>> rules = list(bucket.lifecycle_rules) >>> rules.append({'origin': '/foo', ...}) >>> rules[1]['rule']['action']['type'] = 'Delete' >>> del rules[0] >>> bucket.lifecycle_rules = rules >>> bucket.update() :setter: Set lifecycle rules for this bucket. :getter: Gets the lifecycle rules for this bucket. :rtype: generator(dict) :returns: A sequence of mappings describing each lifecycle rule. lifecyclerwr*rqrnrorzr~zgUnknown lifecycle rule type received: {}. Please upgrade to the latest version of google-cloud-storage.rrN) rr,rmr:ryr}rrformat UserWarning)rLr,rwZ action_typer*r*r1lifecycle_ruless  zBucket.lifecycle_rulescCs"dd|D}|dd|idS)a8Set 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 :type rules: list of dictionaries :param rules: A sequence of mappings describing each lifecycle rule. cSsg|] }t|qSr*)rt)rrwr*r*r1rrz*Bucket.lifecycle_rules..r.rwNr)rLrulesr*r*r1r1s cCs g|_dS)zClear 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 N)r1rbr*r*r1clear_lifecyle_rulesszBucket.clear_lifecyle_rulescKs(t|j}|tfi|||_dS)aAdd a "delete" rule to lifecycle rules configured for this bucket. This defines a [lifecycle configuration](https://cloud.google.com/storage/docs/lifecycle), which is set on the bucket. For the general format of a lifecycle configuration, see the [bucket resource representation for JSON](https://cloud.google.com/storage/docs/json_api/v1/buckets). See also a [code sample](https://cloud.google.com/storage/docs/samples/storage-enable-bucket-lifecycle-management#storage_enable_bucket_lifecycle_management-python). :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. N)rr1appendrmrLrvr2r*r*r1add_lifecycle_delete_rules z Bucket.add_lifecycle_delete_rulecKs*t|j}|t|fi|||_dS)a`Add a "set storage class" rule to lifecycle rules. This defines a [lifecycle configuration](https://cloud.google.com/storage/docs/lifecycle), which is set on the bucket. For the general format of a lifecycle configuration, see the [bucket resource representation for JSON](https://cloud.google.com/storage/docs/json_api/v1/buckets). :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)rr1r4ry)rLr|rvr2r*r*r1$add_lifecycle_set_storage_class_rules z+Bucket.add_lifecycle_set_storage_class_rulecKs(t|j}|tfi|||_dS)aTAdd a "abort incomplete multipart upload" rule to lifecycle rules. .. note:: The "age" lifecycle condition is the only supported condition for this rule. This defines a [lifecycle configuration](https://cloud.google.com/storage/docs/lifecycle), which is set on the bucket. For the general format of a lifecycle configuration, see the [bucket resource representation for JSON](https://cloud.google.com/storage/docs/json_api/v1/buckets). :type kw: dict :params kw: arguments passed to :class:`LifecycleRuleConditions`. N)rr1r4r}r5r*r*r14add_lifecycle_abort_incomplete_multipart_upload_rule s z;Bucket.add_lifecycle_abort_incomplete_multipart_upload_rulercCs|jS)arRetrieve location configured for this bucket. See https://cloud.google.com/storage/docs/json_api/v1/buckets and https://cloud.google.com/storage/docs/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`` ) _locationrbr*r*r1r s 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_MESSAGErr9rr*r*r1r" scCs|jdi}|dS)aRetrieve the list of regional locations for custom dual-region buckets. See https://cloud.google.com/storage/docs/json_api/v1/buckets and https://cloud.google.com/storage/docs/locations Returns ``None`` if the property has not been set before creation, if the bucket's resource has not been loaded from the server, or if the bucket is not a dual-regions bucket. :rtype: list of str or ``NoneType`` ZcustomPlacementConfigZ dataLocationsr)rLZcustom_placement_configr*r*r1data_locations4 s zBucket.data_locationscCs |jdS)a Retrieve the location type for the bucket. See https://cloud.google.com/storage/docs/storage-classes :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``. Z locationTyperrbr*r*r1 location_typeC szBucket.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). loggingrr+r*r*r1 get_loggingU s zBucket.get_loggingcCs||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 )Z logBucketZlogObjectPrefixr=Nr)rLrZ object_prefixr,r*r*r1enable_logginga s zBucket.enable_loggingcCs|dddS)zyDisable access logging for this bucket. See https://cloud.google.com/storage/docs/access-logs#disabling r=Nrrbr*r*r1disable_loggingo szBucket.disable_loggingcCs |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)rLrBr*r*r1rBv s 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)rrrr,rbr*r*r1rE s z Bucket.ownercCs |jd}|durt|SdS)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. Z projectNumberNrC)rLproject_numberr*r*r1rF s zBucket.project_numbercCs2|jd}|dur.|d}|dur.t|SdS)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. retentionPolicyNZ effectiveTimerr,r)rLr timestampr*r*r1retention_policy_effective_time s  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. rGNisLockedr)rLrr*r*r1retention_policy_locked s zBucket.retention_policy_lockedcCs2|jd}|dur.|d}|dur.t|SdS)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. rGNretentionPeriodrC)rLrZperiodr*r*r1retention_period s  zBucket.retention_periodcCs8|jdi}|dur$t||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. rGNrM)rrrr)rLrrr*r*r1rN s cCs |jdS)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. ZselfLinkrrbr*r*r1 self_link s zBucket.self_linkcCs |jdS)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{rrbr*r*r1r| szBucket.storage_classcCs|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`, r{Nrrr*r*r1r| scCs |jd}|durt|SdS)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. Z timeCreatedNrHrr*r*r1 time_created s zBucket.time_createdcCs|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. versioningrFrrLrQr*r*r1versioning_enabled" s zBucket.versioning_enabledcCs|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? rQrNrrrr*r*r1rS2 s cCs|jdi}|ddS)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 requesterPaysFrrRr*r*r1requester_pays> szBucket.requester_payscCs|ddt|idS)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? rUrVNrTrr*r*r1rWO s cCs|jdi}|ddS)aWWhether Autoclass is enabled for this bucket. See https://cloud.google.com/storage/docs/using-autoclass for details. :setter: Update whether autoclass is enabled for this bucket. :getter: Query whether autoclass is enabled for this bucket. :rtype: bool :returns: True if enabled, else False. autoclassrFr)rLrXr*r*r1autoclass_enabled[ s zBucket.autoclass_enabledcCs|ddt|idS)aEnable or disable Autoclass at the bucket-level. See https://cloud.google.com/storage/docs/using-autoclass for details. :type value: convertible to boolean :param value: If true, enable Autoclass for this bucket. If false, disable Autoclass for this bucket. .. note:: To enable autoclass, you must set it at bucket creation time. Currently, only patch requests that disable autoclass are supported. rXrNrTrr*r*r1rYj scCs2|jd}|dur.|d}|dur.t|SdS)a Retrieve the toggle time when Autoclaass was last enabled or disabled for the bucket. :rtype: datetime.datetime or ``NoneType`` :returns: point-in time at which the bucket's autoclass is toggled, or ``None`` if the property is not set locally. rXNZ toggleTimerH)rLrXrIr*r*r1autoclass_toggle_time{ s   zBucket.autoclass_toggle_timecCs||d}|d|dS)aConfigure website-related properties. See https://cloud.google.com/storage/docs/static-website .. note:: This configures the bucket's website-related properties,controlling how the service behaves when accessing bucket contents as a web site. See [tutorials](https://cloud.google.com/storage/docs/hosting-static-website) and [code samples](https://cloud.google.com/storage/docs/samples/storage-define-bucket-website-configuration#storage_define_bucket_website_configuration-python) for more information. :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. )ZmainPageSuffixZ notFoundPageZwebsiteNr)rLZmain_page_suffixZnot_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)r[rbr*r*r1disable_website szBucket.disable_websitecCsX||}i}|jdur"|j|d<|dur2||d<|j|jd|||dd}t|S)a~Retrieve the IAM policy for the bucket. See [API reference docs](https://cloud.google.com/storage/docs/json_api/v1/buckets/getIamPolicy) and a [code sample](https://cloud.google.com/storage/docs/samples/storage-view-bucket-iam-members#storage_view_bucket_iam_members-python). 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. NrZoptionsRequestedPolicyVersion/iamr)rrrrrr:)rLrZrequested_policy_versionrrrr,r*r*r1get_iam_policy s,    zBucket.get_iam_policyc Cs`||}i}|jdur"|j|d<|jd}|}|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. Nrr]Z resourceIdr)rrrZ to_api_reprZ _put_resourcerr:) rLrrrrrrr_r,r*r*r1set_iam_policy s #      zBucket.set_iam_policycCsR||}d|i}|jdur&|j|d<|jd}|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/iam/testPermissionsr)rrrrr,)rLr`rrrrrrespr*r*r1test_iam_permissions s    zBucket.test_iam_permissionsc Cs|j|jj|||||d|rb|j}|jsB|j||d||j|||||d|rt|jd|j d||d} t | |j krd|j f} t | | D]"} | j| jj||dqdS)aiUpdate 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` :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` :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. rrrfullrrrrrzRefusing 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) rallZ grant_readrrloadedrrrrrrI rL recursivefuturerrrrrZdoarrr8r*r*r1 make_publicK sP1 zBucket.make_publicc Cs|j|jj|||||d|rb|j}|jsB|j||d||j|||||d|rt|jd|j d||d} t | |j krd|j f} t | | D]"} | j| jj||dqdS)alUpdate 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` :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` :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. rrcrdrrezRefusing 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) rrfZ revoke_readrrrgrrrrrrIrhr*r*r1 make_private sJ0 zBucket.make_privatec Cs||}|j}t||dur4ttjdd}|d|jig}t||d}t t | d}t ||}|j|j|d|dd}|S)aCreate a signed upload policy for uploading objects. This method generates and signs a policy document. You can use [`policy documents`](https://cloud.google.com/storage/docs/xml-api/post-object-forms) to allow visitors to a website to upload files to Google Cloud Storage without giving them direct write access. See a [code sample](https://cloud.google.com/storage/docs/xml-api/post-object-forms#python). :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) expirationrXzutf-8)r5ZGoogleAccessIdr signature)r _credentialsr Zensure_signed_credentialsrdatetime timedeltar3rbase64 b64encodejsondumpsencodeZ sign_bytesZ signer_emaildecode) rLrXrnr credentialsZpolicy_documentZencoded_policy_documentrorr*r*r1generate_upload_policy s&  zBucket.generate_upload_policycCsd|jvrtd|jd}|dur.td|dr@td||}d|ji}|jdurh|j|d<d |jd }|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. rBz6Bucket has no retention policy assigned: try 'reload'?rGNrKz,Bucket's retention policy is already locked.ZifMetagenerationMatchrrz/lockRetentionPolicyr) rrIr,rrBrr3rr6)rLrrrrrrZ api_responser*r*r1lock_retention_policy? s*       zBucket.lock_retention_policyGEThttpc  Cs|durd}n|dvrtd| r2d|jd}n| rBt| | }n d|j} | sV| rZd} |durr||}|j}|dkrt} nt} | || |||||dS) 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. 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. 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``. :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)r~Zv4z%'version' must be either 'v2' or 'v4'zhttps://z.storage.googleapis.com/)r_rnapi_access_endpointmethodrquery_parameters)rIr3rrrprrupper)rLrnrrrrrryversionZvirtual_hosted_styleZbucket_bound_hostnamerr_helperr*r*r1generate_signed_urlt s8b  zBucket.generate_signed_url)NN)N)NNNN)r?)NN)NN)crfrgrhrirr!rrrrrrZSTORAGE_CLASSESrr rZ_LOCATION_TYPESrKrrkrr6rrrrjrr8r$rrr%rrr(r-rrrr staticmethodrrrrrrrr&rrrrrr Zdefault_event_based_holdrrr)r*r-r1r3r6r7r8r9rr;r<r>r@rArBrErFrJrLrNrOr|rPrSrWrYrZr[r\r^r'r_rbrkrlrzr{_API_ACCESS_ENDPOINTrrlr*r*rYr1rgsF        0  V F.?5     m p ( ' j S u            ,                          A 9 1 c ] 7 7rcKs:|D],\}}|durt||krtd|dqdS)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. N'z+' length must be the same as 'blobs' length)r%rrI) expected_lenZgeneration_match_argsr3rr*r*r1r s r)Krirsrrqru urllib.parserrZgoogle.api_corerZgoogle.cloud._helpersrrrZgoogle.cloud.exceptionsrZgoogle.api_core.iamrZgoogle.cloud.storager Zgoogle.cloud.storage._helpersr r r r rZgoogle.cloud.storage._signingrrrZgoogle.cloud.storage.aclrrZgoogle.cloud.storage.blobrZgoogle.cloud.storage.constantsrrrrrrrrrrr r!Z!google.cloud.storage.notificationr#r$Zgoogle.cloud.storage.retryr%r&r'r(rrrrr:rr2r9r;rtr<rmryr}objectrrrrr*r*r*r1s                                     D" 2,