old-parkingkoncept/parkingkonceptvenv/lib/python3.7/site-packages/s3transfer/__pycache__/bandwidth.cpython-37.pyc

B
<00>[<5B>]=<00>@s<>dd
lZdd
l
Z
Gdd<03>de<02>ZGdd<05>de<04>ZGdd<07>de<04>ZGdd	<09>d	e<04>ZGd
d<0B>de<04>ZGdd
<0A>d
e<04>Z	Gdd<0F>de<04>Z
Gdd<11>de<04>Zd
S)<12>NcseZ
dZ<02>f
d
d<02>Z<03>ZS)<03>RequestExceededExceptioncs,|
|_||_
d
|
|f}tt|<00><02>|<03>

dS)a<>
Error when requested amount exceeds what is allowed

        The request that raised this error should be retried after waiting
        the time specified by ``retry_time``.

        :type requested_amt: int
        :param requested_amt: The originally requested byte amount

        :type retry_time: float
        :param retry_time: The length in time to wait to retry for the
            requested amount
        z<Request amount %s exceeded the amount available. Retry in %sN)<05>
requested_amt<6D>
retry_time<EFBFBD>superr<00>__init__)<04>selfrr<00>msg)
<01>	__class__<5F><00></tmp/pip-install-u_6_z2pz/s3transfer/s3transfer/bandwidth.pyrs




z!RequestExceededException.__init__)<05>__name__<5F>
__module__<EFBFBD>__qualname__r<00>
__classcell__r
r
)
r	rrs
rc
@seZ
dZd
ZdS)<03>RequestTokenzDA token to pass as an identifier when consuming from the LeakyBucketN)rr
r<00>__doc__r
r
r
rr(s

rc@seZ
dZd
d<02>Zdd<04>ZdS)<06>	TimeUtilsc

Cst<00><00>S)
zgGet the current time back

        :rtype: float
        :returns: The current time in seconds
        )
<01>time)
rr
r
rr.szTimeUtils.timecCs
t<00>
|
<01>
S)
zwSleep for a designated time

        :type value: float
        :param value: The time to sleep for in seconds
        )r<00>sleep)r<00>valuer
r
rr6szTimeUtils.sleepN)rr
rrrr
r
r
rr-s
rc@s eZ
dZddd<03>
Zddd<06>
Zd
S)	<09>BandwidthLimiterNcCs |
|_||_
|d
krt<02>|_
d
S)a
Limits bandwidth for shared S3 transfers

        :type leaky_bucket: LeakyBucket
        :param leaky_bucket: The leaky bucket to use limit bandwidth

        :type time_utils: TimeUtils
        :param time_utils: Time utility to use for interacting with time.
        N)<03>
_leaky_bucket<65>_time_utilsr)r<00>leaky_bucket<65>
time_utilsr
r
rr@s	


zBandwidthLimiter.__init__TcCs"t|
|j
||j<02>}|s|<04><03>
|S)
a<>
Wraps a fileobj in a bandwidth limited stream wrapper

        :type fileobj: file-like obj
        :param fileobj: The file-like obj to wrap

        :type transfer_coordinator: s3transfer.futures.TransferCoordinator
        param transfer_coordinator: The coordinator for the general transfer
            that the wrapped stream is a part of

        :type enabled: boolean
        :param enabled: Whether bandwidth limiting should be enabled to start
        )<04>BandwidthLimitedStreamrr<00>disable_bandwidth_limiting)r<00>fileobj<62>transfer_coordinatorZenabled<65>streamr
r
r<00>get_bandwith_limited_streamNs




z,BandwidthLimiter.get_bandwith_limited_stream)
N)
T)rr
rrr r
r
r
rr?s

rc@sneZ
dZddd<04>
Zdd<06>Zdd<08>Zd	d
<EFBFBD>Zdd<0C>Zd
d<0E>Zdd<10>Z	dd<12>Z
dd<14>Zdd<16>Zdd<18>Z
dd<1A>Zd
S)rN<>cCsF|
|_||_
||_||_|d
kr(t<04>|_d|_t<06>|_d|_||_	d
S)a[Limits bandwidth for reads on a wrapped stream

        :type fileobj: file-like object
        :param fileobj: The file like object to wrap

        :type leaky_bucket: LeakyBucket
        :param leaky_bucket: The leaky bucket to use to throttle reads on
            the stream

        :type transfer_coordinator: s3transfer.futures.TransferCoordinator
        param transfer_coordinator: The coordinator for the general transfer
            that the wrapped stream is a part of

        :type time_utils: TimeUtils
        :param time_utils: The time utility to use for interacting with time
        NTr
)
<EFBFBD>_fileobjr<00>_transfer_coordinatorrr<00>_bandwidth_limiting_enabledr<00>_request_token<65>_bytes_seen<65>_bytes_threshold)rrrrrZbytes_thresholdr
r
rres








zBandwidthLimitedStream.__init__c

Cs
d
|_dS)z0Enable bandwidth limiting on reads to the streamTN)
r$)
rr
r
r<00>enable_bandwidth_limiting<6E>sz0BandwidthLimitedStream.enable_bandwidth_limitingc

Cs
d
|_dS)z1Disable bandwidth limiting on reads to the streamFN)
r$)
rr
r
rr<00>sz1BandwidthLimitedStream.disable_bandwidth_limitingcCsL|js|j
<01>|
<01>
S|j|
7_|j|jkr8|j
<01>|
<01>
S|<00><05>
|j
<01>|
<01>
S)
zhRead a specified amount

        Reads will only be throttled if bandwidth limiting is enabled.
        )r$r"<00>readr&r'<00>_consume_through_leaky_bucket)r<00>amountr
r
rr)<00>s



zBandwidthLimitedStream.readc

Cshxb|jj
sZy|j<02>|j|j<05>
d
|_dStk
rV
}

z|j<07>|
j	<09>

Wdd}
~
XYqXqW|jj
<01>
dS)Nr
)
r#<00>	exceptionr<00>consumer&r%rrrr)r<00>
er
r
rr*<00>s







$z4BandwidthLimitedStream._consume_through_leaky_bucketc

Cs|<00><00>
d
S)z6Signal that data being read is being transferred to S3N)
r()
rr
r
r<00>signal_transferring<6E>sz*BandwidthLimitedStream.signal_transferringc

Cs|<00><00>
d
S)z:Signal that data being read is not being transferred to S3N)
r)
rr
r
r<00>signal_not_transferring<6E>sz.BandwidthLimitedStream.signal_not_transferringcCs|j<00>
|
<01>

dS)
N)r"<00>seek)r<00>wherer
r
rr1<00>s
zBandwidthLimitedStream.seekc

Cs
|j<00>
<01>S)
N)r"<00>tell)
rr
r
rr3<00>s
zBandwidthLimitedStream.tellc

Cs"|jr|j
r|<00><02>
|j<03><04>
dS)
N)r$r&r*r"<00>close)
rr
r
rr4<00>s

zBandwidthLimitedStream.closec


Cs|S)
Nr
)
rr
r
r<00>	__enter__<5F>s
z BandwidthLimitedStream.__enter__c
Os|<00><00>
dS)
N)
r4)r<00>args<67>kwargsr
r
r<00>__exit__<5F>s
zBandwidthLimitedStream.__exit__)Nr!)rr
rrr(rr)r*r/r0r1r3r4r5r8r
r
r
rrds

rc@s>eZ
dZddd<03>
Zdd<05>Zdd<07>Zdd	<09>Zd
d<0B>Zdd
<0A>Zd
S)<0F>LeakyBucketNcCsZt|
<01>
|_
||_|d
kr t<03>|_t<04><05>|_||_|d
kr@t<08>|_||_	|d
krVt
<EFBFBD>|_	d
S)a9A leaky bucket abstraction to limit bandwidth consumption

        :type rate: int
        :type rate: The maximum rate to allow. This rate is in terms of
            bytes per second.

        :type time_utils: TimeUtils
        :param time_utils: The time utility to use for interacting with time

        :type rate_tracker: BandwidthRateTracker
        :param rate_tracker: Tracks bandwidth consumption

        :type consumption_scheduler: ConsumptionScheduler
        :param consumption_scheduler: Schedules consumption retries when
            necessary
        N)<0B>float<61>	_max_raterr<00>	threading<6E>Lock<63>_lock<63>
_rate_tracker<65>BandwidthRateTracker<65>_consumption_scheduler<65>ConsumptionScheduler)rZmax_raterZrate_trackerZconsumption_schedulerr
r
rr<00>s











zLeakyBucket.__init__c	Csb|j<00>R
|j
<01><02>}|j<03>|<02>
r,|<00>|
||<03>S|<00>|
|<03>rH|<00>|
||<03>
n|<00>|
|<03>SWd
QRXd
S)acConsume an a requested amount

        :type amt: int
        :param amt: The amount of bytes to request to consume

        :type request_token: RequestToken
        :param request_token: The token associated to the consumption
            request that is used to identify the request. So if a
            RequestExceededException is raised the token should be used
            in subsequent retry consume() request.

        :raises RequestExceededException: If the consumption amount would
            exceed the maximum allocated bandwidth

        :rtype: int
        :returns: The amount consumed
        N)	r>rrrA<00>is_scheduled<65>,_release_requested_amt_for_scheduled_request<73>_projected_to_exceed_max_rate<74>!_raise_request_exceeded_exception<6F>_release_requested_amt)r<00>amt<6D>
request_token<65>time_nowr
r
rr-<00>s








zLeakyBucket.consumecCs|j<00>
|
|<02>}||jkS)
N)r?<00>get_projected_rater;)rrHrJZprojected_rater
r
rrE

s

z)LeakyBucket._projected_to_exceed_max_ratecCs|j<00>
|<02>

|<00>|
|<03>S)
N)rA<00>process_scheduled_consumptionrG)rrHrIrJr
r
rrD
s

z8LeakyBucket._release_requested_amt_for_scheduled_requestcCs.|
t|j
<01>
}|j<02>|
||<04>}t|
|d
<01><02>
dS)N)rr)r:r;rA<00>schedule_consumptionr)rrHrIrJZallocated_timerr
r
rrF
s






z-LeakyBucket._raise_request_exceeded_exceptioncCs|j<00>
|
|<02>
|
S)
N)r?<00>record_consumption_rate)rrHrJr
r
rrG
s

z"LeakyBucket._release_requested_amt)NNN)	rr
rrr-rErDrFrGr
r
r
rr9<00>s


r9c@s,eZ
dZd
d<02>Zdd<04>Zdd<06>Zdd<08>Zd	S)
rBc

Csi|_d
|_
dS)z*Schedules when to consume a desired amountr
N)<02> _tokens_to_scheduled_consumption<6F>_total_wait)
rr
r
rr!
s
zConsumptionScheduler.__init__cCs
|
|jkS)
z<>Indicates if a consumption request has been scheduled

        :type token: RequestToken
        :param token: The token associated to the consumption
            request that is used to identify the request.
        )
rO)r<00>tokenr
r
rrC&
sz!ConsumptionScheduler.is_scheduledcCs&|j|7_|j|d
<01>|j
|<|jS)a<>Schedules a wait time to be able to consume an amount

        :type amt: int
        :param amt: The amount of bytes scheduled to be consumed

        :type token: RequestToken
        :param token: The token associated to the consumption
            request that is used to identify the request.

        :type time_to_consume: float
        :param time_to_consume: The desired time it should take for that
            specific request amount to be consumed in regardless of previously
            scheduled consumption requests

        :rtype: float
        :returns: The amount of time to wait for the specific request before
            actually consuming the specified amount.
        )Z
wait_duration<6F>time_to_consume)rPrO)rrHrQrRr
r
rrM/
s
z)ConsumptionScheduler.schedule_consumptioncCs&|j<00>
|
<01>
}t|j|d
d<02>|_dS)z<>Processes a scheduled consumption request that has completed

        :type token: RequestToken
        :param token: The token associated to the consumption
            request that is used to identify the request.
        rRr
N)rO<00>pop<6F>maxrP)rrQZscheduled_retryr
r
rrLI
s

z2ConsumptionScheduler.process_scheduled_consumptionN)rr
rrrCrMrLr
r
r
rrB 
s
	rBc@sBeZ
dZddd<03>
Zedd<05><00>
Zdd<07>Zdd	<09>Zd
d<0B>Zdd
<0A>Z	dS)r@皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cCs|
|_d
|_
d
|_d
S)a<>
Tracks the rate of bandwidth consumption

        :type a: float
        :param a: The constant to use in calculating the exponentional moving
            average of the bandwidth rate. Specifically it is used in the
            following calculation:

            current_rate = alpha * new_rate + (1 - alpha) * current_rate

            This value of this constant should be between 0 and 1.
        N)<03>_alpha<68>
_last_time<EFBFBD>
_current_rate)r<00>alphar
r
rrV
s

zBandwidthRateTracker.__init__c

Cs|jd
krdS|j
S)zmThe current transfer rate

        :rtype: float
        :returns: The current tracked transfer rate
        Ng)rWrX)
rr
r
r<00>current_ratef
s


z!BandwidthRateTracker.current_ratecCs|jd
krdS|<00>
|
|<02>S)aZ
Get the projected rate using a provided amount and time

        :type amt: int
        :param amt: The proposed amount to consume

        :type time_at_consumption: float
        :param time_at_consumption: The proposed time to consume at

        :rtype: float
        :returns: The consumption rate if that amt and time were consumed
        Ng)rW<00>*_calculate_exponential_moving_average_rate)rrH<00>time_at_consumptionr
r
rrKq
s



z'BandwidthRateTracker.get_projected_ratecCs2|jd
kr||_d|_
d
S|<00>|
|<02>|_
||_d
S)a
Record the consumption rate based off amount and time point

        :type amt: int
        :param amt: The amount that got consumed

        :type time_at_consumption: float
        :param time_at_consumption: The time at which the amount was consumed
        Ng)rWrXr[)rrHr\r
r
rrN<00>
s	







z,BandwidthRateTracker.record_consumption_ratecCs"||j}|d
k
rt
d<02>
S|
|S)Nr
<00>inf)rWr:)rrHr\Z
time_deltar
r
r<00>_calculate_rate<74>
s



z$BandwidthRateTracker._calculate_ratecCs&|<00>|
|<02>}|j
|d
|j
|jS)N<>
)r^rVrX)rrHr\Znew_rater
r
rr[<00>
s
z?BandwidthRateTracker._calculate_exponential_moving_average_rateN)
rU)
rr
rr<00>propertyrZrKrNr^r[r
r
r
rr@U
s


r@)rr<<00>	Exceptionr<00>objectrrrrr9rBr@r
r
r
r<00><module>
s
%jR5