s,g ddlZddlZddlZddlZddlZddlmZddlmZmZm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZddlmZddlmZmZe rdd lmZdd lmZdd lm Z dd l!m"Z"dd l#m$Z$ddl%m&Z&m'Z'ddl(m)Z)ddlm*Z*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mGddedgdZ?e GddZ@y)N) namedtuple)datetime timedeltatimezone)total_ordering) TYPE_CHECKINGAnyCallableDictListOptionalTupleTypeUnioncast) WatchError)BaseDeathPenaltyUnixSignalDeathPenalty)Redis)Pipeline)Retry)DEFAULT_RESULT_TTL) Dependency)DequeueTimeoutNoSuchJobError)IntermediateQueue)CallbackJob JobStatus)bluegreen)resolve_serializer)FunctionReferenceTypeJobDependencyType)as_text backend_classcompact get_versionimport_attributenow parse_timeoutzrq.queueceZdZdZdZy) EnqueueDataz^Helper type to use when calling enqueue_many NOTE: Does not support `depends_on` yet. N)__name__ __module__ __qualname____doc__ __slots__r/b/var/www/trellinator.diamondhoofcare.com/public_html/venv/lib/python3.12/site-packages/rq/queue.pyr.r."s.Ir5r.funcargskwargstimeout result_ttlttl failure_ttl description depends_onjob_idat_frontmetaretry on_success on_failure on_stoppedc&eZdZUeZeded<eZee ed<dZ e ed<dZ e ed<dZe ed <e dud d deeddeee d edfdZe dude d d deeddedeee d df dZdd d dd d efde d ed dee dedeee edfdedeee fdZdZdZdZd ee e e ffdZedZedZed e fdZ!edZ"ed ee fd Z#d efd!Z$d"Z%d#Z&dvd$efd%Z'd efd&Z(ed efd'Z)d(e d edfd)Z*d*ede fd ee fd+Z+dwd,e d-e d ee fd.Z,dwd,e d-e d edfd/Z-ed ee fd0Z.ed edfd1Z/ed e fd2Z0ed3Z1ed4Z2ed5Z3ed6Z4ed7Z5ed8Z6dxd*ede fd9ed:fd;Z7d<Z8dyd(e d9ed:d=efd>Z9d d d d d d d d d d e:jvd f d d d d d?d@dAdBeeed fdCee<dDee dEee dFee dGee dHee dIedJd(ee dKee<dLe:dMedNdOeee=e>fdPeee=e>fdQeee=e>fdRee d ef$dSZ?dxdTdd9ed:d dfdUZ@ dzd@dAdBeeed fdCee<dDee dEee dFee dGee dHee dIedJd(ee d=edKee<dMedNdOeee=e>dVeffdPeee=e>dVeffdQeee=e>dVeffd9ed:d ef$dWZAeB d{d@dAdBeeed fdCee<dDee dEee dFee dGee dHee dIeed(ee d=edKee<dMedNdOeee=e>fdPeee=e>fdQeee=e>fd eCf"dXZD d|dYedZd9ed:dRee d eefd[ZEdTdd efd\ZFed}d]ZGd~d^ZHd_eIfd`ZJdxdTdd_eId9ed:fdaZKdbeLd@dAd dfdcZMdydTdd9ed:d=ed efddZNdydTdd9ed:d=ed efdeZOddfZP d|dTdd9ed:dgee fdhZQd ee fdiZRedxdjee dDee d ed fdkZSed d de dDee fdlZTe dudmeddDee d d deeddedeee d eednfdoZUdpZVdqZWdrZXdsZYdtZZy )Queuer job_classdeath_penalty_classDEFAULT_TIMEOUTz rq:queue:redis_queue_namespace_prefixz rq:queuesredis_queues_keysN connectionrreturncdtttfffd }jj}|Dcgc] }|s||}}|Scc}w)aReturns an iterable of all Queues. Args: connection (Optional[Redis], optional): The Redis Connection. Defaults to None. job_class (Optional[Job], optional): The Job class to use. Defaults to None. serializer (optional): The serializer to use. Defaults to None. death_penalty_class (Optional[Job], optional): The Death Penalty class to use. Defaults to None. Returns: queues (List[Queue]): A list of all queues. queue_keycBjt|S)NrPrJ serializerrK)from_queue_keyr&)rSclsrPrKrJrVs r6to_queuezQueue.all..to_queue\s/%% "%#%$7 & r5)rbytesstrsmembersrO) rXrPrJrVrKrYall_registerd_queuesrq_key all_queuess ````` r6allz Queue.allHs\( eSj 1   *2233H3HI5IT6Vhv&T TUs A ArSrVc|j}|j|stdj||t |d}||||||S)aReturns a Queue instance, based on the naming conventions for naming the internal Redis keys. Can be used to reverse-lookup Queues by their Redis keys. Args: queue_key (str): The queue key connection (Redis): Redis connection. Defaults to None. job_class (Optional[Job], optional): Job class. Defaults to None. serializer (Any, optional): Serializer. Defaults to None. death_penalty_class (Optional[BaseDeathPenalty], optional): Death penalty class. Defaults to None. Raises: ValueError: If the queue_key doesn't start with the defined prefix Returns: queue (Queue): The Queue object zNot a valid RQ queue key: {0}NrU)rN startswith ValueErrorformatlen)rXrSrPrJrVrKprefixnames r6rWzQueue.from_queue_keyis`411##F+<CCINO OV' !! 3   r5defaultTrgdefault_timeoutis_asyncc |s td||_|j} ||_dj | ||_t |xs |j|_||_ t|_ d|vr$|d|_ tjdt|(t|t rt#||_n||_||_t)||_d|_y)aInitializes a Queue object. Args: name (str, optional): The queue name. Defaults to 'default'. default_timeout (Optional[int], optional): Queue's default timeout. Defaults to None. connection (Optional[Redis], optional): Redis connection. Defaults to None. is_async (bool, optional): Whether jobs should run "async" (using the worker). If `is_async` is false, jobs will run on the same process from where it was called. Defaults to True. job_class (Union[str, 'Job', optional): Job class or a string referencing the Job class path. Defaults to None. serializer (Any, optional): Serializer. Defaults to None. death_penalty_class (Type[BaseDeathPenalty, optional): Job class or a string referencing the Job class path. Defaults to UnixSignalDeathPenalty. z V$BVBV! f #G_DN MMUWi j  )S)!1)!<!*#6 ,Z8DH!r5c|jSNcountrxs r6__len__z Queue.__len__s zzr5cy)NTr/r~s r6__bool__zQueue.__bool__sr5c#K|ywr{r/r~s r6__iter__zQueue.__iter__s  scf|jst|j|_|jS)zReturn Redis server version of connection Returns: redis_version (Tuple): A tuple with the parsed Redis version (eg: (5,0,0)) )rwr)rPr~s r6get_redis_server_versionzQueue.get_redis_server_versions* (((3DOO(DD %(((r5c|jS)z%Returns the Redis key for this Queue.)rnr~s r6keyz Queue.keysyyr5c@tj|jS)z-Returns the Redis key for intermediate queue.)rget_intermediate_queue_keyrnr~s r6intermediate_queue_keyzQueue.intermediate_queue_keys!;;DIIFFr5cDt|j|jS)z6Returns the IntermediateQueue instance for this Queue.rP)rrrPr~s r6intermediate_queuezQueue.intermediate_queues!dooFFr5c d|jzS)z7Redis key used to indicate this queue has been cleaned.zrq:clean_registries:%s)rgr~s r6registry_cleaning_keyzQueue.registry_cleaning_keys($))33r5cddlm}|jj|j |j }|t |jSdS)Nr) RQScheduler) rq.schedulerrrPgetget_locking_keyrgintdecode)rxrpids r6 scheduler_pidzQueue.scheduler_pidsB,oo!!+"="=dii"HI$'Os3::< ==r5c^|jj|jddd}|sy|S)zReturns a boolean indicating whether a lock to clean this queue is acquired. A lock expires in 899 seconds (15 minutes - 1 second) Returns: lock_acquired (bool) rTi)nxexF)rPsetr)rx lock_acquireds r6acquire_maintenance_lockzQueue.acquire_maintenance_locks4++D,F,FdWZ+[ r5cN|jj|jy)z?Deletes the maintenance lock after registries have been cleanedN)rPdeleterr~s r6release_maintenance_lockzQueue.release_maintenance_locks t99:r5cdj|jjjd}|jj |}||j gS)aRemoves all messages on the queue. This is currently being done using a Lua script, which iterates all queue messages and deletes the jobs and it's dependents. It registers the Lua script and calls it. Even though is currently being returned, this is not strictly necessary. Returns: script (...): The Lua Script is called. a local prefix = "{0}" local q = KEYS[1] local count = 0 while true do local job_id = redis.call("lpop", q) if job_id == false then break end -- Delete the relevant keys redis.call("del", prefix..job_id) redis.call("del", prefix..job_id..":dependents") count = count + 1 end return count zutf-8)keys)rdrJredis_job_namespace_prefixencoderPregister_scriptr)rxscripts r6emptyz Queue.emptysQ F4>><< =ffWo! "008DHH:&&r5 delete_jobsc(|r|j|jj5}|j|j|j |j |j |jdddy#1swYyxYw)zDeletes the queue. Args: delete_jobs (bool): If true, removes all the associated messages on the queue first. N)rrPpipelinesremrOrnrexecute)rxrrs r6rz Queue.deletesk  JJL __ % % ' 8 MM$00$)) < OODII &       s ABBc |jdk(S)z~Returns whether the current queue is empty. Returns: is_empty (bool): Whether the queue is empty rr|r~s r6is_emptyzQueue.is_empty+s zzQr5c,t|jS)z+Returns whether the current queue is async.)boolrpr~s r6rjzQueue.is_async3sDNN##r5rAc |jj||j|j}|j|j k(r|Sy#t $r|j|YywxYw)aHFetch a single job by Job ID. If the job key is not found, will run the `remove` method, to exclude the key. If the job has the same name as as the current job origin, returns the Job Args: job_id (str): The Job ID Returns: job (Optional[Job]): The job if found rPrVN)rJfetchrPrVoriginrgrremove)rxrAjobs r6 fetch_jobzQueue.fetch_job8si ..&&v$//VZVeVe&fCzzTYY&   KK    s2AA-,A- job_or_idcLttt||jr |jn|}|j dk\r' |j j|j|S||jvr|jj|Sy#t$rY5wxYw)aReturns the position of a job within the queue Using Redis before 6.0.6 and redis-py before 3.5.4 has a complexity of worse than O(N) and should not be used for very long job queues. Redis and redis-py version afterwards should support the LPOS command handling job positions within Redis c implementation. Args: job_or_id (Union[Job, str]): The Job instance or Job ID Returns: _type_: _description_ )rrN) rr[rvrJidrrPlposrAttributeErrorjob_idsindex)rxrrAs r6get_job_positionzQueue.get_job_positionMsc:i+P9<r?r@r%rCstatusrDrrErFrGrct|}| |j}n|dk(r tdt|}t|}t|}||dkr td|jj ||||j |||| || || |j | |j||||}| r"| j|_ | j|_ |S)a6Creates a job based on parameters given Args: func (FunctionReferenceType): The function referce: a callable or the path. args (Union[Tuple, List, None], optional): The `*args` to pass to the function. Defaults to None. kwargs (Optional[Dict], optional): The `**kwargs` to pass to the function. Defaults to None. timeout (Optional[int], optional): Function timeout. Defaults to None, use -1 for infinite timeout. result_ttl (Optional[int], optional): Result time to live. Defaults to None. ttl (Optional[int], optional): Time to live. Defaults to None. failure_ttl (Optional[int], optional): Failure time to live. Defaults to None. description (Optional[str], optional): The description. Defaults to None. depends_on (Optional[JobDependencyType], optional): The job dependencies. Defaults to None. job_id (Optional[str], optional): Job ID. Defaults to None. meta (Optional[Dict], optional): Job metadata. Defaults to None. status (JobStatus, optional): Job status. Defaults to JobStatus.QUEUED. retry (Optional[Retry], optional): The Retry Object. Defaults to None. on_success (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on success. Defaults to None. Callable is deprecated. on_failure (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on failure. Defaults to None. Callable is deprecated. on_stopped (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on stopped. Defaults to None. Callable is deprecated. pipeline (Optional[Pipeline], optional): The Redis Pipeline. Defaults to None. group_id (Optional[str], optional): A group ID that the job is being added to. Defaults to None. Raises: ValueError: If the timeout is 0 ValueError: If the job TTL is 0 or negative Returns: Job: The created job rz50 timeout is not allowed. Use -1 for infinite timeoutzJob ttl must be greater than 0)r9r:rPr<r=r>rr?r@r;rrrCrVrErFrGr) r,rorcrJcreaterPrgrVmax retries_left intervalsretry_intervals)rxr8r9r:r;r<r=r>r?r@rArCrrDrErFrGrrs r6 create_jobzQueue.create_jobsj ( ?++G \TU U":. #K0 C  ?sax=> >nn## !##!99!!!'$ , $yyC "'//C  r5rct|jdkDr|jd}||n|jj } |j |j |jd|}|j|D]}|jdtjk7s'|jtj||j||j||j|j |||j#|cS |S||j|S#t$$r| ||_YwxYw)acIf a _dependent_ job depends on any unfinished job, register all the _dependent_ job's dependencies instead of enqueueing it. `Job#fetch_dependencies` sets WATCH on all dependencies. If WatchError is raised in the when the pipeline is executed, that means something else has modified either the set of dependencies or the status of one of them. In this case, we simply retry. Args: job (Job): The job pipeline (Optional[Pipeline], optional): The Redis Pipeline. Defaults to None. Returns: job (Job): The Job rFrefreshT)watchrrr=r)re_dependency_ids get_statusrPrrdependencies_keyfetch_dependenciesmultir FINISHED set_statusDEFERREDregister_dependencysavecleanupr=rr_status)rxrr orig_statuspipe dependencies dependencys r6setup_dependencieszQueue.setup_dependenciesRsO s"" #a '...7K'389Q9Q9SD JJs334# #9t#9#TLJJL&2 ' %000?9CUCUU NN9+=+=NM33T3BHHdH3KKCGGdKC'/ $ #&J '  ! NN  " ' '2   s A&E3A7E+EEE.c|j|||||||| | | tj|| |||}|j||| S)a/Creates a job to represent the delayed function call and enqueues it. It is much like `.enqueue()`, except that it takes the function's args and kwargs as explicit arguments. Any kwargs passed to this function contain options for RQ itself. Args: func (FunctionReferenceType): The reference to the function args (Union[Tuple, List, None], optional): THe `*args` to pass to the function. Defaults to None. kwargs (Optional[Dict], optional): THe `**kwargs` to pass to the function. Defaults to None. timeout (Optional[int], optional): Function timeout. Defaults to None. result_ttl (Optional[int], optional): Result time to live. Defaults to None. ttl (Optional[int], optional): Time to live. Defaults to None. failure_ttl (Optional[int], optional): Failure time to live. Defaults to None. description (Optional[str], optional): The job description. Defaults to None. depends_on (Optional[JobDependencyType], optional): The job dependencies. Defaults to None. job_id (Optional[str], optional): The job ID. Defaults to None. at_front (bool, optional): Whether to enqueue the job at the front. Defaults to False. meta (Optional[Dict], optional): Metadata to attach to the job. Defaults to None. retry (Optional[Retry], optional): Retry object. Defaults to None. on_success (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on success. Defaults to None. Callable is deprecated. on_failure (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on failure. Defaults to None. Callable is deprecated. on_stopped (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on stopped. Defaults to None. Callable is deprecated. pipeline (Optional[Pipeline], optional): The Redis Pipeline. Defaults to None. Returns: Job: The enqueued Job )r9r:r<r=r>r?r@rArCrr;rDrErFrGrrB)rr QUEUED enqueue_job)rxr8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrrs r6 enqueue_callzQueue.enqueue_callshhoo !##!##!!!! $hJJr5c6t|||||||||| | | | | ||S)amNeed this till support dropped for python_version < 3.7, where defaults can be specified for named tuples And can keep this logic within EnqueueData Args: func (FunctionReferenceType): The reference to the function args (Union[Tuple, List, None], optional): THe `*args` to pass to the function. Defaults to None. kwargs (Optional[Dict], optional): THe `**kwargs` to pass to the function. Defaults to None. timeout (Optional[int], optional): Function timeout. Defaults to None. result_ttl (Optional[int], optional): Result time to live. Defaults to None. ttl (Optional[int], optional): Time to live. Defaults to None. failure_ttl (Optional[int], optional): Failure time to live. Defaults to None. description (Optional[str], optional): The job description. Defaults to None. depends_on (Optional[JobDependencyType], optional): The job dependencies. Defaults to None. job_id (Optional[str], optional): The job ID. Defaults to None. at_front (bool, optional): Whether to enqueue the job at the front. Defaults to False. meta (Optional[Dict], optional): Metadata to attach to the job. Defaults to None. retry (Optional[Retry], optional): Retry object. Defaults to None. on_success (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on success. Defaults to None. Callable is deprecated. on_failure (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on failure. Defaults to None. Callable is deprecated. on_stopped (Optional[Union[Callback, Callable[..., Any]]], optional): Callback for on stopped. Defaults to None. Callable is deprecated. Returns: EnqueueData: The EnqueueData )r.r7s r6 prepare_datazQueue.prepare_datasB\                !  r5 job_datasr.c @||n|jj}g}g}g}fd}|D cgc]} | jr| } } | rb| D cgc]E} |j|jdi|| t j || jG}} ||j|D cgc]} | js| } } | r| D cgc])} |jdi|| t j+} } | D]} | j|||jtj| |\}}|D cgc] } |j| || j"}} ||j||z|zScc} wcc} wcc} wcc} wcc} w)auCreates multiple jobs (created via `Queue.prepare_data` calls) to represent the delayed function calls and enqueues them. Args: job_datas (List['EnqueueData']): A List of job data pipeline (Optional[Pipeline], optional): The Redis Pipeline. Defaults to None. Returns: List[Job]: A list of enqueued jobs cid|jd|jd|jd|jd|jd|j d|j d|jd |jd |jd |d |jd |jd|jd|jd|jdS)Nr8r9r:r<r=r>r?r@rArCrr;rDrErFrGr)r8r9r:r<r=r>r?r@rArCr;rDrErFrG)job_datainitial_statusrs r6get_job_kwargsz*Queue.enqueue_many..get_job_kwargs&s!  (//h11  x||  x33 x33h11(// .8++h11h11 h11!"H# r5rrr/)rPrr@ _enqueue_jobrr rrBrrrrget_jobs_with_met_dependenciesenqueue_at_front)rxrrrrjobs_without_dependenciesjobs_with_unmet_dependenciesjobs_with_met_dependenciesr$r"job_datas_without_dependenciesjob_datas_with_dependenciesjobs_with_dependenciesrs ` r6 enqueue_manyzQueue.enqueue_manys$/xT__5M5M5O$&!')$%'" ,DM)hxT\TgTg()h&)h )!? )  !!#DOOQnXy?O?O&PQ!%..") %) @I&aHXM`M`x&a#&a &!<& O.9;M;M"NO& "&. ($' ( HRGpGp&H D &(D 6*!!#s?S?S!T* &* (+GGJdddI*i)'b&*s*FF A F /FF .F%Fc<|jt|_|jt}|j j 5}|j|||j|||jddd|S#1swY|SxYw)zzRun the job Args: job (Job): The job to run Returns: Job: _description_ ) default_ttl)r<rrN) performr+ended_atget_result_ttlrrPr_handle_successrr)rxrr<rs r6run_jobz Queue.run_jobbs u ''4F'G __ % % ' 8   :  I KK XK 6        s 7BBct|ts|jdk(r td|j dd}|j dd}|j dd}|j dd}|j dd}|j d d} |j d d} |j d d } |j d d} |j dd} |j dd}|j dd}|j dd}|j dd}d|vsd|vr0|dk(sJd|j dd}|j dd}||||||| | | | | ||||||fS)a Parses arguments passed to `queue.enqueue()` and `queue.enqueue_at()` The function argument `f` may be any of the following: * A reference to a function * A reference to an object's instance method * A string, representing the location of a function (must be meaningful to the import context of the workers) Args: f (FunctionReferenceType): The function reference args (*args): function args kwargs (*kwargs): function kargs __main__zAFunctions from the __main__ module cannot be processed by workers job_timeoutNr?r<r=r>r@rArBFrCrDrErFrGrr9r:r/zMExtra positional arguments cannot be used when using explicit args and kwargs)rvr[r1rcpop)rXfr9r:r;r?r<r=r>r@rArBrCrDrErFrGrs r6 parse_argszQueue.parse_argsts"!S!allj&@`a a**]D1jj5 ZZ d3 jj%jj5 ZZ d3 Hd+::j%0zz&$' 7D)ZZ d3 ZZ d3 ZZ d3 ::j$/ V x612: nn n:::fd+DZZ$/F                 #  r5ctj|g|i|\}}}}}}} } } } } }}}}}}|j||||||||| | | | | ||||S)auCreates a job to represent the delayed function call and enqueues it. Receives the same parameters accepted by the `enqueue_call` method. Args: f (FunctionReferenceType): The function reference args (*args): function args kwargs (*kwargs): function kargs Returns: job (Job): The created Job )r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGr)rIr;r)rxr:r9r:r;r?r<r=r>r@rArBrCrDrErFrGrs r6enqueuez Queue.enqueues<   Q 0 0 0%                  !##!!!!#!  r5rctj|g|i|\}}}}}} } } } } }}}}}}}|j|tj|||||| || | | ||||}| rd|_|j |||S)zSchedules a job to be enqueued at specified time Args: datetime (datetime): _description_ f (_type_): _description_ Returns: _type_: _description_ )rr9r:r;r<r=r>r?r@rArCrDrErFrGTr)rIr;rr SCHEDULEDr' schedule_job)rxrr:r9r:r;r?r<r=r>r@rArBrCrDrErFrGrrs r6 enqueue_atzQueue.enqueue_ats8   Q 0 0 0%                oo &&!##!!!!! $ #'C   h BBr5cddlm}||}||n|jj}|j |j |j |j||j|||||j|S)aPuts job on ScheduledJobRegistry Args: job (Job): _description_ datetime (datetime): _description_ pipeline (Optional[Pipeline], optional): _description_. Defaults to None. Returns: _type_: _description_ rr)rr) registryrrPrsaddrOrrscheduler)rxrrrrrCrs r6r@zQueue.schedule_jobs{ 3'd3#/xT__5M5M5O $(($((3 $#x$7   LLN r5 time_deltacx|jtjtj|z|g|i|S)aSchedules a job to be executed in a given `timedelta` object Args: time_delta (timedelta): The timedelta object func (FunctionReferenceType): The function reference Returns: job (Job): The enqueued Job )rArr+rutc)rxrFr8r9r:s r6 enqueue_inzQueue.enqueue_in2s4tx||HLL9JF^t^W]^^r5ch|j|_|j||}||n|jj }|j |j |j||j|jdtjk7r|j|||S|S)a}Enqueues a job for delayed execution checking dependencies. Args: job (Job): The job to enqueue pipeline (Optional[Pipeline], optional): The Redis pipeline to use. Defaults to None. at_front (bool, optional): Whether should enqueue at the front of the queue. Defaults to False. Returns: Job: The enqued job rFrr) rgrrrPrrDrOrrrr rr%rxrrrBrs r6rzQueue.enqueue_job>sYY %%cH%=#/xT__5M5M5O $(($((3   LLN >>%> (I,>,> >$$S8h$O O r5c8||n|jj}|j|_|j t j ||j|_t|_ |j|j|_ |j||j|j||j r|j#|j$||||j'|j s|j)|}|S)aEnqueues a job for delayed execution without checking dependencies. If Queue is instantiated with is_async=False, job is executed immediately. Args: job (Job): The job to enqueue pipeline (Optional[Pipeline], optional): The Redis pipeline to use. Defaults to None. at_front (bool, optional): Whether should enqueue at the front of the queue. Defaults to False. Returns: Job: The enqued job rrr)rPrrrwr r rrgrr+ enqueued_atr;rorrr=rprrrrun_syncrKs r6r%zQueue._enqueue_jobUs$/xT__5M5M5O#'#@#@#B  y''$7YY % ;; //CK $ $ / >>   SVVdX  F   LLN~~--$C r5c|jj5}|jd|ddd |j|}|jr+|j ||j|j |S#1swYTxYw#|jj5}|j tj|djtjtj}|j|||jdddn #1swYnxYw|j r0|j ||jgtjY|SxYw)zRun a job synchronously, meaning on the same process the method was called. Args: job (Job): The job to run Returns: Job: The job instance syncNr)rPrprepare_for_executionr5success_callback return_valuer r FAILEDjoin tracebackformat_exceptionsysexc_info_handle_failurerfailure_callback)rxrr exc_strings r6rNzQueue.run_synczs1__ % % ' 88  % %fh 7 8 O,,s#C##$$S$//3;K;K;MN % 8 8  L))+ #xy//(CWWY%?%?%PQ ##J9  "  # # # ##$$$S$//KCLLNK  s0BB B  E4)A7D) E4)D2 .AE4exclude_job_idcddlm}||n|jj}|j} ||j ||j |Dchc] }t|}}|sy|jj||j|jD cgc]=} | r9| j||r%| jdtjk7r| ?} } |j| sy| D]} | j xsd} || j"|j|j|j} | j%| | | j"|j&k(r|j)| || |j+| j"|j }|j)| || t-| t-|k(r|j/|n,| Dcgc]}|j0}}|j2|g|||j5ycc}wcc} wcc}w#t6$r|YwxYw) aEnqueues all jobs in the given job's dependents set and clears it. When called without a pipeline, this method uses WATCH/MULTI/EXEC. If you pass a pipeline, only MULTI is called. The rest is up to the caller. Args: job (Job): The Job to enqueue the dependents pipeline (Optional[Pipeline], optional): The Redis Pipeline. Defaults to None. exclude_job_id (Optional[str], optional): Whether to exclude the job id. Defaults to None. rrNr) parent_jobrr^Fr)rJrVrr)rgrP)rCrrPrdependents_keyrr\r&rJ fetch_manyrVdependencies_are_metrr CANCELEDr r'rrrgr% __class__rerrrrr)rxrrr^rrra_iddependent_job_ids dependent_jobjobs_to_enqueue dependentr'rCrenqueued_job_idss r6enqueue_dependentszQueue.enqueue_dependentssP 2#/xT__5M5M5O++> #JJ~.=A]]>=Z$[cWS\$[!$[)*.)B)B)dooRVRaRa*C* #%%%::#&!%'5; &000?9CUCUU" # # &!0 `I'0'A'A'JU$2!(($//T^^`d`o`o HOOIO= ''4994)))dM])^ $I4D4DQUQ`Q` a**9tN^*_ `'3/@+AAKK/:I'J3'J$'JDIIn@/?@#LLNa%\ #J(K  #  sI&H9H*+H904H9$AH/&H9;C4H9/H4'H9*H99 I I c^t|jj|jS)zjPops a given job ID from this Redis queue. Returns: job_id (str): The job id )r&rPrrr~s r6 pop_job_idzQueue.pop_job_ids" t++DHH566r5 queue_keysc ||dk(r tddjtt|Dcgc]}t t|c}}t j d|d||sJ|j||}|$t j d|t|||\}}||fS|D]}|sJ|j|} | || fcSycc}w)aHelper method to abstract away from some Redis API details where LPOP accepts only a single key, whereas BLPOP accepts multiple. So if we want the non-blocking LPOP, we need to iterate over all queues, do individual LPOPs, and return the result. Until Redis receives a specific method for this, we'll have to wrap it this way. The timeout parameter is interpreted as follows: None - non-blocking (return immediately) > 0 - maximum number of seconds to block Args: queue_keys (_type_): _description_ timeout (Optional[int]): _description_ connection (Optional[Redis], optional): _description_. Defaults to None. Raises: ValueError: If timeout of 0 was passed DequeueTimeout: BLPOP Timeout Returns: _type_: _description_ NrHRQ does not support indefinite timeouts. Please pick a timeout value > 0z, z$Starting BLPOP operation for queues  with timeout of z'BLPOP timeout, no jobs found on queues ) rcrVmapr[r"rqrblpoprr) rXror;rPrcolored_queuesrrSrAblobs r6rz Queue.lpops4  !| !kll!YYs3PZ0[us5z1B0['\]N LL??OO`ah`ij k :%%j':F~ F~FVWX$Wj99 & Ivf$ $' + !!z!y1#$d?*  + 1\sCct||}|}|dk(r tdt|}tj d|d||j ||j |}|$tj d|t||||fSttt|j||j }|||fSy)zSimilar to lpop, but accepts only a single queue key and immediately pushes the result to an intermediate queue. NrrqzStarting BLMOVE operation for rrz!BLMOVE timeout, no jobs found on ) rrcr"rqrblmoverrrr r lmove)rXrPrSr;r colored_queuers r6ryz Queue.lmove!s /y*E  !| !kll!),M LL9-HYZaYbc d$.$5$5iASAWAWY`$aF~ @PQ$Wi88f$ $(3-)9)9)EWE[E[)\]F! &((r5queues)rrIct|d|} |Dcgc]}|j} }t| dk(r%t|dk\r|j || d|} n|j | ||} | yt t| \} } |j| ||||} |j| || }|| fScc}w#t$rYt$r}| |_ | |_ |d}~wwxYw) aOClass method returning the job_class instance at the front of the given set of Queues, where the order of the queues is important. When all of the Queues are empty, depending on the `timeout` argument, either blocks execution of this function for the duration of the timeout or until new messages arrive on any of the queues, or returns None. See the documentation of cls.lpop for the interpretation of timeout. Args: queues (List[Queue]): List of queue objects timeout (Optional[int]): Timeout for the LPOP connection (Optional[Redis], optional): Redis Connection. Defaults to None. job_class (Optional[Type[Job]], optional): The job class. Defaults to None. serializer (Any, optional): Serializer to use. Defaults to None. death_penalty_class (Optional[Type[BaseDeathPenalty]], optional): The death penalty class. Defaults to None. Raises: e: Any exception Returns: job, queue (Tuple[Job, Queue]): A tuple of Job, Queue rJ)overrider)rrrrNrUr)r'rrer)ryrrsr&rWrr ExceptionrAr)rXr{r;rPrJrVrKjob_clsqrorrSrArres r6 dequeue_anyzQueue.dequeue_any7s D+3 iP)/0A!%%0J0:!# J(?9(L:z!}gF*g*M~ #GV 4 Iv&&%!%$7 'E mmFzjmY: 71""  "  s#B5B:: C"C" CC"cjt|ts td|j|jk(SNz&Cannot compare queues to other objectsrvrIrmrgrxothers r6__eq__z Queue.__eq__{s+%'DE EyyEJJ&&r5cjt|ts td|j|jkSrrrs r6__lt__z Queue.__lt__s+%'DE Eyy5::%%r5c,t|jSr{)hashrgr~s r6__hash__zQueue.__hash__sDIIr5cbdj|jj|jS)Nz {0}({1!r})rdrer0rgr~s r6__repr__zQueue.__repr__s#""4>>#:#:DIIFFr5cbdj|jj|jS)Nz <{0} {1}>rr~s r6__str__z Queue.__str__s#!!$.."9"9499EEr5)NNN)T)rr{)NF)NNNNNNNNNFNNNNNN)NNNNNNNNNFNNNNN)NN)r:r$)r:r$rQr)rrrQr)[r0r1r2rrJr__annotations__rrKrrMrrNr[rO classmethodr r r`r rWrrryrrrrrpropertyrrrrrrrrrrrrjrrrrrrr}rrrrrrrr(rr rr rr rrr staticmethodr.rr.r5r;r=rrAr@rrIrr%rNrlrnrryrrrrrrr/r5r6rIrI@s  ItE{ 2H./HOS(3 #3(s(,0@D DK( &d+;&<=  g @ ,0@D # # # DK( #  # &d+;&<= #  # # N(,)-7;@V0I0IW%0I"# 0I  0I E#tE{"234 0I0I&d+;&<=0Id)%S# *>)GGG$5GG44>x}>> $ ;'< $ $$$$$*%s *; 6#3S & Gs G GT%[ G"c""d5k.s..cc dd eeee ff ee 9eSj 19Xj=Q9" 8T#T*1ETX\T**.!%!%$(!%)%)48 $#%,,#'] ;?:>:>"&']%]E4%&] ] # ] SM ]c]]c]]c]]01] ]tn]] ] U8X#567!]"U8X#567#]$U8X#567%]&3-']( )]~7e7x 7K7W\7x*.!%!%$(!%)%)48 $##'DHDHDH)-%FK%FKE4%&FK FK # FK SM FKc]FKc]FKc]FK01FK FKFKtnFK FKU8Xc3h-?#?@AFK U8Xc3h-?#?@A!FK"U8Xc3h-?#?@A#FK$:&%FK& 'FKP*.!%!%$(!%)%)%) $##':>:>:>!> %> E4%&> > # > SM > c] > c]> c]> TN>  > > tn>  > U8X#567> U8X#567> U8X#567!> " #> > BptLem,Le8@8LLe_ghk_lLe cLe\5S$; ; z2 h1C81CfXjEY2 _Y _6M _ch _u0DW[hk.##*1E#X\#il#J<bfRR$,Z$8RQYZ]Q^Rh7HSM7+d3i+(3-+XV]M^++Zw3#* ,0@D?W ?#? ? DK( ?  ?&d+;&<=? %' (??F' & GFr5rI)AloggingrYrWrrs collectionsrrrr functoolsrtypingrr r r r r rrrrredisrtimeoutsrrr redis.clientrrrdefaultsrrr exceptionsrrrrrrr logutilsr!r" serializersr#typesr$r%utilsr&r'r(r)r*r+r, getLoggerrqr.rIr/r5r6rs  "22$___>%("61))!+;eee   : & <KFKFKFr5