s,gUddlZddlZddlZddlZddlZddlZddlmZmZmZddl m Z ddl m Z m Z mZmZmZmZmZmZmZmZmZddlmZddlmZddlmZmZdd lmZm Z e r6dd l!m"Z"dd lm#Z#dd l$m%Z%dd l&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.GddZ/ddl0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEejdZGGddeHe ZIdeHdeHfdZJGddZKeLZMdeNd < d/d!eHd"d#d$eOfd%ZPd0d"ed#d&ed'ded'fd(ZQd1d!eHd"d#dd'fd)ZRGd*d'ZSe5ZTGd+d,ZUGd-d.ZVy)2N)datetime timedeltatimezone)Enum) TYPE_CHECKINGAnyCallableDictIterableListMappingOptionalTupleTypeUnion)uuid4) WatchError)CALLBACK_TIMEOUT#UNSERIALIZABLE_RETURN_VALUE_PAYLOAD)BaseDeathPenaltyJobTimeoutException)ExcInfo)Redis)Pipeline)Unpack) ExecutionExecutionRegistryQueueResultc eZdZy)UnevaluatedTypeN)__name__ __module__ __qualname__`/var/www/trellinator.diamondhoofcare.com/public_html/venv/lib/python3.12/site-packages/rq/job.pyr$r$s r)r$)DeserializationErrorInvalidJobOperationNoSuchJobError) LocalStack)resolve_serializer)FunctionReferenceTypeJobDependencyType) as_textdecode_redis_hash ensure_listget_call_string get_versionimport_attributenow parse_timeout str_to_date utcformatzrq.jobc0eZdZdZdZdZdZdZdZdZ dZ d Z y ) JobStatusz9The Status of Job within its lifecycle at any given time.queuedfinishedfailedstarteddeferred scheduledstoppedcanceledN) r%r&r'__doc__QUEUEDFINISHEDFAILEDSTARTEDDEFERRED SCHEDULEDSTOPPEDCANCELEDr(r)r*r=r=3s-C FH FGHIGHr)r=job_or_execution_idreturnc6d|vr|jddS|S)zbParse a string and returns job ID. This function supports both job ID and execution composite key.:r)split)rOs r* parse_job_idrT@s' !!"((-a00 r)c2eZdZddeedefdedefdZy) DependencyjobsJob allow_failureenqueue_at_frontct|}td|Ds tdt|dkr td||_||_||_y)aThe definition of a Dependency. Args: jobs (List[Union[Job, str]]): A list of Job instances or Job IDs. Anything different will raise a ValueError allow_failure (bool, optional): Whether to allow for failure when running the depency, meaning, the dependencies should continue running even after one of them failed. Defaults to False. enqueue_at_front (bool, optional): Whether this dependecy should be enqueued at the front of the queue. Defaults to False. Raises: ValueError: If the `jobs` param has anything different than `str` or `Job` class or the job list is empty c3fK|])}|st|txst|t+ywN) isinstancerXstr).0jobs r* z&Dependency.__init__..Xs)aC]`:c3'?:c3+??as1'1zJjobs: must contain objects of type Job and/or strings representing Job idsrzjobs: cannot be empty.N)r4all ValueErrorlen dependenciesrYrZ)selfrWrYrZdependent_jobss r*__init__zDependency.__init__HsY%T*a>aaij j  1 $56 6** 0r)N)FF)r%r&r'r rr_boolrir(r)r*rVrVGs+1T%s "341T1ei1r)rV UNEVALUATEDjob_id connectionrenqueue_dependentscTtj|||j|y)aCancels the job with the given job ID, preventing execution. Use with caution. This will discard any job info (i.e. it can't be requeued later). Args: job_id (str): The Job ID connection (Optional[Redis], optional): The Redis Connection. Defaults to None. serializer (str, optional): The string of the path to the serializer to use. Defaults to None. enqueue_dependents (bool, optional): Whether dependents should still be enqueued. Defaults to False. rm serializer)rnN)rXfetchcancel)rlrmrqrns r* cancel_jobrths%IIf ICJJ^pJqr) job_classrXc|rtjdt|rtjdttjS)aReturns the Job instance that is currently being executed. If this function is invoked from outside a job context, None is returned. Args: connection (Optional[Redis], optional): The connection to use. Defaults to None. job_class (Optional[Job], optional): The job class (DEPRECATED). Defaults to None. Returns: job (Optional[Job]): The current Job running z6connection argument for get_current_job is deprecated.z5job_class argument for get_current_job is deprecated.)warningswarnDeprecationWarning _job_stacktop)rmrus r*get_current_jobr|us4 NPbc MOab >>r)cRtj|||}|jS)aGFetches a Job by ID and requeues it using the `requeue()` method. Args: job_id (str): The Job ID that should be requeued. connection (Redis): The Redis Connection to use serializer (Optional[str], optional): The serializer. Defaults to None. Returns: Job: The requeued Job object. rp)rXrrrequeue)rlrmrqras r* requeue_jobrs$ ))Fzj) IC ;;=r)c, eZdZUdZeded<dZddeededfdZe ddddd d e d ee e e fd eeeefdedd eedeedeedeedeedeedeededeeeefdeedeedee dedeffdee dedeffdee dedeffddf&dZdeefdZddedeefd Zdded!ed"ddfd#Zddedefd$Zedefd%Zedefd&Zedefd'Zedefd(Zedefd)Zedefd*Z edefd+Z!edefd,Z"ed-Z#ededfd.Z$ede%efd/Z&ed0Z'ed1Z(edefd2Z)ed3Z*edefd4Z+ed5Z,edefd6Z-d7Z.ed8Z/e/j`d9Z/ed:Z1e1j`d;Z1ed<Z2e2j`d=Z2ede e e ffd>Z3e3j`d?Z3edeeeffd@Z4e4j`dAZ4e dBedddefdCZ5e ddededddfdDZ6e ddEe7eddde%edfdFZ8dGZ9dHZ:dIZ;dJZddNe?ded!ed"dOefdPZ@ee=e>ZAe dBedeBfdQZCe dBedefdRZDedSZEedTZFedUZGddVed!ed"de%dfdWZHedeefdXZIddedeefdYZJedefdZZKde%d[fd\ZLddeded[fd]ZMdefd^ZNd_ZOdd`edaedePfdbZQdd!ed"d`edaefdcZRedefddZSdeTeeeffdeZUdfZVdd!ed"dgefdhZWddieddfdjZXeddkZYde%dlfdmZZdd!ed"dnefdoZ[ dd!ed"dnedpefdqZ\dd!ed"fdrZ]defdsZ^dted!d"fduZ_defdvZ`ddweedeefdxZadwedefdyZbdeefdzZcddeed!ed"dnefd{Zded|Zeed}Zfed~ZgdeheidefdZjdeheifdZkdeheifdZld ed!d"fdZmded!d"fdZnddZodefdZpedefdZqddZrdd!ed"fdZsede%eBfdZt ddedd!ed"deedefdZuy)rXzHA Job is just a convenient datastructure to pass around job (meta) data. _dependencyzrq:job:Nidrmrc|s td||_||_t|_t |_t |_t |_t |_ t |_ d|_ t |_ d|_ t |_d|_t |_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_ g|_!i|_"tG||_$d|_%d|_&d|_'d|_(d|_)d|_*d|_+d|_,ddl-m.}d|_/y)Nz8Job.__init__() missing 1 required argument: 'connection'rr!)0 TypeErrorrm_idr8 created_atrk_data _func_name _instance_args_kwargs_success_callback_name_success_callback_failure_callback_name_failure_callback_stopped_callback_name_stopped_callback descriptionorigin enqueued_at started_atended_at_result _exc_infotimeout_success_callback_timeout_failure_callback_timeout_stopped_callback_timeout result_ttl failure_ttlttl worker_name_status_dependency_idsmetar/rq retries_leftnumber_of_retriesretry_intervalsredis_server_versionlast_heartbeatallow_dependency_failuresrZgroup_idresultsr"_cached_result)rgrrmrqr"s r*riz Job.__init__s^VW W$%  9DEPF$ .<CCDIJ J&$'>EEfMN NZJ? > JJrN CJ   D ! MMCM!]]CN    %):):4)@&--doot?P?PQCN c "$T]CN&74+D CM'CNKRRSWXY Y  j(3 j&&j1 )3C &,6,>,>C ) j(3 j&&j1 )3C &,6,>,>C ) j(3 j&&j1 )3C &,6,>,>C )&>)<)<)>&z2' 4$#G,  :2   ! O#.z#: Ioz:,/+?+?+c?CcCcC(474Q4Q4rUdUrUrC1#**?+G+GH#**;+GH IWf"fsZS-A366s#J"fC  #gs0%Ocddlm}|jr9||j|j}|j |j Sy)zsGet's the job's position on the queue Returns: position (Optional[int]): The position rr)rrmN)queuer rrmget_job_positionr)rgr qs r* get_positionzJob.get_positionus: ! ;;4;;4??CA%%dgg. .r)refreshc|rY|jj|jd}|std|jt t ||_|jS)a3Gets the Job Status Args: refresh (bool, optional): Whether to refresh the Job. Defaults to True. Raises: InvalidJobOperation: If refreshing and nothing is returned from the `HGET` operation. Returns: status (JobStatus): The Job Status rz#Failed to retrieve status for job: )rmhgetkeyr,rr=r2r)rgrrs r* get_statuszJob.get_statussX __))$((H=F),OPTPWPWy*YZZ$WV_5DL||r)pipelinerc||_||n |j}|j|jd|jy)zSet's the Job Status Args: status (JobStatus): The Job Status to be set pipeline (Optional[Pipeline], optional): Optional Redis Pipeline to use. Defaults to None. Nr)rrmhsetr)rgrrrms r* set_statuszJob.set_statuss3 *2*>hDOO (DLL9r)c|rJ|jj|jd}|r|jj |ni|_|j S)zGet's the metadata for a Job, an arbitrary dictionary. Args: refresh (bool, optional): Whether to refresh. Defaults to True. Returns: meta (Dict): The dictionary of metadata r)rmrrrqloadsr)rgrrs r*get_metaz Job.get_metasE ??''&9D7;--d3DIyyr)cD|jtjk(Sr])rr=rHrgs r* is_finishedzJob.is_finished I$6$666r)cD|jtjk(Sr])rr=rGrs r* is_queuedz Job.is_queued I$4$444r)cD|jtjk(Sr])rr=rIrs r* is_failedz Job.is_failedrr)cD|jtjk(Sr])rr=rJrs r* is_startedzJob.is_started I$5$555r)cD|jtjk(Sr])rr=rKrs r* is_deferredzJob.is_deferredrr)cD|jtjk(Sr])rr=rNrs r* is_canceledzJob.is_canceledrr)cD|jtjk(Sr])rr=rLrs r* is_scheduledzJob.is_scheduleds I$7$777r)cD|jtjk(Sr])rr=rMrs r* is_stoppedzJob.is_stoppedrr)c:|jr|jdSy)z}Returns the first item in self._dependency_ids. Present to preserve compatibility with third party packages. rN)rrs r*_dependency_idzJob._dependency_ids#   ''* * r)c|jsyt|dr |jS|j|jd|j|j }||_|S)zReturns a job's first dependency. To avoid repeated Redis fetches, we cache job.dependency as job._dependency. Nrrrp)rrrrrrmrq)rgras r* dependencyzJob.dependencys] ## 4 '## #jj--a0T__Y]YhYhji r)czttt|jj |j S)zaReturns a list of ids of jobs whose execution depends on this job's successful execution.)rmapr2rmsmembersdependents_keyrs r* dependent_idszJob.dependent_idss+C!9!9$:M:M!NOPPr)c|j}|y|jrt|j|St|jSr]) func_nameinstancegetattrr7)rgrs r*rzJob.funcs;NN   ==4==)4 4//r)c|jtur9|jr&t|j|_|jSd|_|jSr])rrkrr7rs r*success_callbackzJob.success_callbackP  ! ![ 0**)9$:U:U)V&%%%*.&%%%r)c>|jtS|jSr])rrrs r*success_callback_timeoutzJob.success_callback_timeout  ) ) 1# #---r)c|jtur9|jr&t|j|_|jSd|_|jSr])rrkrr7rs r*failure_callbackzJob.failure_callbackrr)c>|jtS|jSr])rrrs r*failure_callback_timeoutzJob.failure_callback_timeoutrr)c|jtur9|jr&t|j|_|jSd|_|jSr])rrkrr7rs r*stopped_callbackzJob.stopped_callbackrr)c>|jtS|jSr])rrrs r*stopped_callback_timeoutzJob.stopped_callback_timeout!rr)c |jj|j\|_|_|_|_y#t$r}t|d}~wwxYw)zDeserializes the Job `data` into a tuple. This includes the `_func_name`, `_instance`, `_args` and `_kwargs` Raises: DeserializationError: Cathes any deserialization error (since serializers are generic) N) rqrdatarrrr Exceptionr+)rges r*_deserialize_datazJob._deserialize_data(sN 0HLH]H]^b^g^gHh EDOT^TZ 0&(a / 0s>A A AAc|jtur|jtur td|jturd|_|j turd|_|j turi|_|j|j|j |j f}|jj||_|jS)NzCannot build the job datar() rrkrrdrrrrqdumps)rg job_tuples r*rzJob.data4s :: $+- !<==~~,!%zz[( ||{*! T\\QI..y9DJzzr)cj||_t|_t|_t|_t|_yr])rrkrrrrrgvalues r*rzJob.dataGs% %$  " r)c^|jtur|j|jSr])rrkrrs r*rz Job.func_nameOs$ ??k )  " " $r)c(||_t|_yr])rrkrrs r*rz Job.func_nameUs  r)c^|jtur|j|jSr])rrkrrs r*rz Job.instanceZs$ >>[ (  " " $~~r)c(||_t|_yr])rrkrrs r*rz Job.instance`s  r)c^|jtur|j|jSr])rrkrrs r*rzJob.argses$ :: $  " " $zzr)c(||_t|_yr])rrkrrs r*rzJob.argsks   r)c^|jtur|j|jSr])rrkrrs r*rz Job.kwargsps$ <<; &  " " $||r)c(||_t|_yr])rrkrrs r*rz Job.kwargsvs   r)rlc\|j|}|j|}t|S)aChecks whether a Job Hash exists for the given Job ID Args: job_id (str): The Job ID connection (Optional[Redis], optional): Optional connection to use. Defaults to None. Returns: job_exists (bool): Whether the Job exists )key_forexistsrj)rrlrmjob_key job_existss r*r"z Job.exists{s-++f%&&w/ Jr)cN|t|||}|j|S)aFetches a persisted Job from its corresponding Redis key and instantiates it Args: id (str): The Job to fetch connection (Optional['Redis'], optional): An optional Redis connection. Defaults to None. serializer (_type_, optional): The serializer to use. Defaults to None. Returns: Job: The Job instance rp)rTr)rrrmrqras r*rrz Job.fetchs%,r"zjQ  r)job_idsc|Dcgc] }t|}}|j5}|D]"}|j|j|$|j }dddg}t |D]L\} }| s|j d||||} | j|| |j | N|Scc}w#1swYlxYw)a Bulk version of Job.fetch For any job_ids which a job does not exist, the corresponding item in the returned list will be None. Args: job_ids (Iterable[str]): A list of job ids. connection (Redis): Redis connection serializer (Callable): A serializer Returns: jobs (list[Optional[Job]]): A list of Jobs instances, elements are None if a job_id does not exist. Nrp)rTrhgetallr!execute enumerateappendrestore) rr&rmrqrl parsed_idsrrrWiras r* fetch_manyzJob.fetch_manys :AAvl6*A A  " )h$ 6  V!45 6&&(G ) ')":. IAv1: D!f KC KK # KK   !B ) )sC8C  Ccxdj|jj|j|jS)Nz{0}({1!r}, enqueued_at={2!r}))r __class__r%rrrs r*__repr__z Job.__repr__s,.55dnn6M6MtxxY]YiYijjr)cxdj|jj|j|jS)Nz<{0} {1}: {2}>)rr1r%rrrs r*__str__z Job.__str__s+&&t~~'>'>IYIYZZr)cdt||jxr|j|jk(Sr])r^r1r)rgothers r*__eq__z Job.__eq__s%%0HTWW5HHr)c,t|jSr])hashrrs r*__hash__z Job.__hash__sDGG}r)cb|jtt|_|jS)zThe job ID for this job instance. Generates an ID lazily the first time the ID is requested. Returns: job_id (str): The Job ID )rr_rrs r*get_idz Job.get_ids$ 88 57|DHxxr)rct|ts#tdjt |d|vr t d||_y)zkSets a job ID for the given job Args: value (str): The value to set as Job ID zid must be a string, not {0}rRzid must not contain ":"N)r^r_rrtyperdrrs r*rz Job.set_idsC %%:AA$u+NO O %<67 7r) timestampxxc||_||n |j}|j|jdt |jy)aSets the heartbeat for a job. It will set a hash in Redis with the `last_heartbeat` key and datetime value. If a Redis' pipeline is passed, it will use that, else, it will use the job's own connection. Args: timestamp (datetime): The timestamp to use ttl (int): The time to live pipeline (Optional[Pipeline], optional): Can receive a Redis' pipeline to use. Defaults to None. xx (bool, optional): Only sets the key if already exists. Defaults to False. Nr)rrmrrr;)rgr?rrr@rms r* heartbeatz Job.heartbeats<(!)!5X4?? "2Id>Q>Q4RSr)c>|j|zjdS)zThe Redis key that is used to store job hash under. Args: job_id (str): The Job ID Returns: redis_job_key (bytes): The Redis fully qualified key for the job utf-8)redis_job_namespace_prefixencoderrls r*r!z Job.key_fors ..7??HHr)c:dj|j|S)zThe Redis key that is used to store job dependents hash under. Args: job_id (str): The "parent" job id Returns: dependents_key (str): The dependents key z{0}{1}:dependents)rrErGs r*dependents_key_forzJob.dependents_key_fors#))#*H*H&QQr)c8|j|jS)z3The Redis key that is used to store job hash under.)r!rrs r*rzJob.key s||DGG$$r)c8|j|jS)z>The Redis key that is used to store job dependents hash under.)rIrrs r*rzJob.dependents_keys&&tww//r)cNdj|j|jS)Nz{0}:{1}:dependencies)rrErrs r*dependencies_keyzJob.dependencies_keys%,,T-L-LdggVVr)watchcJ||n |j}|rB|jr6|j|jDcgc]}|j|c}|j |j|j|j }|Dcgc]}|s| }}|Scc}wcc}w)aFetch all of a job's dependencies. If a pipeline is supplied, and watch is true, then set WATCH on all the keys of all dependencies. Returned jobs will use self's connection, not the pipeline supplied. If a job has been deleted from redis, it is not returned. Args: watch (bool, optional): Wether to WATCH the keys. Defaults to False. pipeline (Optional[Pipeline]): The Redis' pipeline to use. Defaults to None. Returns: jobs (list[Job]): A list of Jobs rp)rmrrNr!r/rq)rgrNrrm dependency_iddependencies_listrarWs r*fetch_dependencieszJob.fetch_dependenciess"*!5X4?? T)) J  PTPdPde}t||M:e f OO  T__,  18C88 f 9sB B B cRtjdtddlm}|j rp|j s|j|_|j rC|j j|jjk(r|j jS|jS)zf Get the latest result and returns `exc_info` only if the latest result is a failure. zrrI exc_stringrrgr"s r*exc_infoz Job.exc_info5s|  TVhi#  & &&&&*&8&8&:#""t':':'?'?6;;CUCU'U**555~~r)cddlm}|rd|_|jsm|j |jS|j j |jd}|,|jj||_|jSy|js|j|_|jrC|jj|jjk(r|jjSy)a Returns the return value of the latest execution, if it was successful. Args: refresh (bool, optional): Whether to refresh the current status. Defaults to False. Returns: result (Optional[Any]): The job return value. rr!Nresult)rr"rrTrrmrrrqrrUr>r SUCCESSFUL return_value)rgrr"rvs r*r\zJob.return_valueGs $ "&D **||'||#%%dhh9B~#44R8 ||#"""&"4"4"6D    4#6#6#;#;v{{?U?U#U&&33 3r)ctjdtddlm}|j rp|j s|j|_|j rC|j j|jjk(r|j jS|jH|jj|jd}| |j j#||_ |jS)aReturns the return value of the job. Initially, right after enqueueing a job, the return value will be None. But when the job has been executed, and had a return value or exception, this will return that value or exception. Note that, when the job has no return value (i.e. returns None), the ReadOnlyJob object is useless, as the result won't be written back to Redis. Also note that you cannot draw the conclusion that a job has _not_ been executed when its return value is None, since return values written back to Redis will expire after a given amount of time (500 seconds by default). z7job.result is deprecated, use job.return_value instead.rr!rZ)rwrxryrr"rTrrUr>rr[r\rrmrrrqr)rgr"r]s r*rZz Job.resulths$  OQcd#  & &&&&*&8&8&:#""t':':'?'?6;;CYCY'Y**777 << %%dhh9B~#44R8 ||r)r"cJddlm}|j||jS)zxReturns all Result objects Returns: all_results (List[Result]): A list of 'Result' objects rr!)rq)rr"rcrqrWs r*rz Job.resultss $vzz$4??;;r)cLddlm}|j||j|S)zGet the latest job result. Args: timeout (int, optional): Number of seconds to block waiting for a result. Defaults to 0 (no blocking). Returns: result (Result): The Result object rr!)rqr)rr" fetch_latestrq)rgrr"s r*rUzJob.latest_results" $"v""4DOOWUUr)c t|} |d} t j ||_t|jd|_ |jdrt|dnd|_ |jdr|djnd|_|jdrt|dnd|_t|jd |_t|jd |_t|jd |_t|jd |_|jd rt|d nd|_|jd}|r! |j*j-||_|jdrt5|jdnd|_|jdrt9|dnd|_|jdrt9|dnd|_|jdrt?t|dnd|_ |jdr|dj|_!d|vrt9|d|_"|jdr|dj|_#d|vrt9|d|_$|jdr|dj|_%d|vrt9|d|_&|jd}|jd}|r#tOj,|jn|r|jgng|_(|jd}|rtSt9|nd|_*d|vrtSt9|dnd|_+|jdrt9|dnd|_, |jdr|j*j-|dni|_-|jd rt9|d nd|_.|jd!rt9|d!nd|_/|jd"r+tOj,|d"j|_0|jd#}|r% tt j ||_1yy#t$rtdj|wxYw#tj$r ||_YwxYw#t0$rt2|_YwxYw#t0$rd|jdii|_-YIwxYw#tj$rt||_1YywxYw)$zOverwrite properties with the provided values stored in Redis. Args: raw_data (_type_): The raw data to load the job data from Raises: NoSuchJobError: If there way an error getting the job data rzUnexpected job format: {0}rrrrNrrrrrrrZrrrrsuccess_callback_namerfailure_callback_namerstopped_callback_namer dependency_idsrPrrZrr unserializedrrrrX)2r3KeyErrorr-rzlib decompressrerrorr:getrr2rdecoderrrrrrrrqrrrrr9rintrrr=rrrrrrrjsonrrjrrZrrrrrr)rgraw_dataobjrZdep_idsdep_idallow_failures raw_exc_infos r*r,z Job.restores ) K6{H !1DI &cggl&;<030Agc(m,r :=''-:P3}-446VZ:=''-:P73}#56VZ&sww}'=>%cggl&;<#CGGJ$78 )#''2B*CD47GGJ4GJ0T "  C#44V< =@GGI>Aggfo--c&k:SUDICF''J]B^S)<%=!>dh8;8OCN 34UY 77$ %#'::c2C.D.K.K.M#ND wwz*  7!()F!G C K !=!D!DS!IJ J K zz ! DI !" CB  CD >')<=DI >:: 7!(!6 7sRSS<9 T6T80#U!$S9<TTT54T58"UU!#VVc|jj|j}|s$tdj |j|j |y)zOverwrite the current instance's properties with the values in the corresponding Redis key. Will raise a NoSuchJobError if no corresponding Redis key exists. zNo such job: {0}N)rmr(rr-rr,)rgrs r*rz Job.refreshsF &&txx0 !3!:!:488!DE E Tr) include_metainclude_resultc t|jxs ttj|j |j r |j nd|jr |jnd|jr |jnd|jrt|jnd|jrt|jnd|jrt|jnd|jxsd|jxsdd }|j|j|d<|j|j|d<|j "t#j$|j |d<|j&r|j&|d<|j(|j(|d<|j*t|j*|d<|j,+|r) |j.j%|j,|d <|j0<|r:tjt3|j0j5d |d <|j6|j6|d <|j8|j8|d<|j:|j:|d<|j<|j<|d<|j>|j>|d<|j@|j@|d<|jB|jB|d<|jDr4|jDd|d<t#j$|jD|d<|jFr*|r(|j.j%|jF|d<|jHr|jH|d<|jJtM|jJ|d<|jNtM|jN|d<|S#d |d <YxYw)aReturns a serialization of the current job instance You can exclude serializing the `meta` dictionary by setting `include_meta=False`. Args: include_meta (bool, optional): Whether to include the Job's metadata. Defaults to True. include_result (bool, optional): Whether to include the Job's result. Defaults to True. Returns: dict: The Job serialized as a dictionary r) rrrcrdrerrrrrrrrrrrrZzUnserializable return valuerDrXrrrr rrrrrPrfrrrrZ)(r;rr8ricompressrrrrrrrrrrrrrorrrrrrqrr_rFrrrrrrrrrrrrnrZ)rgrwrxrqs r*to_dictz Job.to_dicts\$DOO$ $ 5 5dll CH  >> %."mmC,?,F,Fw,OPC O << #!\\C N  ) ) 5.2.L.LC* +  ) ) 5.2.L.LC* +  ) ) 5.2.L.LC* + ?? & $C     '!%!1!1C  << # LLCM   #'#7#7#:C $(JJt/C/C$DC ! 99//// :CK 88CJ  ) ) 5/243Q3Q/RC+ ,  ,&)$*?*?&@C" # C > =H s (O&&O0c|j}||n |j}|j||}|j||y)aDumps the current job instance to its corresponding Redis key. Exclude saving the `meta` dictionary by setting `include_meta=False`. This is useful to prevent clobbering user metadata without an expensive `refresh()` call first. Redis key persistence may be altered by `cleanup()` method. Args: pipeline (Optional[Pipeline], optional): The Redis' pipeline to use. Defaults to None. include_meta (bool, optional): Whether to include the job's metadata. Defaults to True. include_result (bool, optional): Whether to include the job's result. Defaults to True. N)rwrxmapping)rrmr{r)rgrrwrxrrmr~s r*savezJob.saveRs?hh!)!5X4?? ,,L,XW-r)c(|jdk\S)z2Only supported by Redis server >= 5.0 is required.)rr)get_redis_server_versionrs r*rTzJob.supports_redis_streamsfs,,.);;r)cf|jt|j|_|jS)zReturn Redis server version of connection Returns: redis_server_version (Tuple[int, int, int]): The Redis version within a Tuple of integers, eg (5, 0, 9) )rr6rmrs r*rzJob.get_redis_server_versionks-  $ $ ,(3DOO(DD %(((r)c|jj|j}|jj |j d|y)zEStores job meta from the job instance to the corresponding Redis key.rN)rqrrrmrr)rgrs r* save_metaz Job.save_metavs4$$TYY/ TXXvt4r)rnc|jr(tdj|jddlm}ddlm}|xs|jj} ||j|j|j|j}|jtj||r;||j!|j"|j%|||j& |j)|d ||j|j|j|j }|j+||||j-y#t.$r|YwxYw) aCancels the given job, which will prevent the job from ever being ran (or inspected). This method merely exists as a high-level API call to cancel jobs without worrying about the internals required to implement job cancellation. You can enqueue the jobs dependents optionally, Same pipelining behavior as Queue.enqueue_dependents on whether or not a pipeline is passed in. Args: pipeline (Optional[Pipeline], optional): The Redis' pipeline to use. Defaults to None. enqueue_dependents (bool, optional): Whether to enqueue dependents jobs. Defaults to False. Raises: InvalidJobOperation: If the job has already been cancelled. z&Cannot cancel already canceled job: {}rrCanceledJobRegistryT)rrmrurqrN)rexclude_job_idrremove_from_queue)rurq)rr,rr<rr registryrrmrrr1rqrr=rNrNrrnr_remove_from_registriesaddr)r)rgrrnr rpiperrs r*rsz Job.cancel{sB$   %&N&U&UVZVaVaVc&de e 154??335 DNNgkgvgv 2 2TB%' 4#6#67((QUQXQX(Y,,dd,S.KKDNNW[WfWf TD 1#LLN #  s!C>E E0.E0at_frontc<|jj||S)zRequeues job Args: at_front (bool, optional): Whether the job should be requeued at the front of the queue. Defaults to False. Returns: job (Job): The requeued Job instance )r)failed_job_registryr~)rgrs r*r~z Job.requeues ''//x/HHr)cJddlm}||j|jS)Nr)r)rm) executionsrrrm)rgrs r*execution_registryzJob.execution_registrys1 T__EEr)rc6|jjSr])rget_executionsrs r*rzJob.get_executionss&&5577r)rcddlm}|rBddlm}||j|j |j }|j|||jrNddlm }||j|j |j|j }|j||y|jrNddlm }||j|j |j|j }|j||y|jradd lm} | |j|j |j|j }|j|||j||y|j rNdd lm} | |j|j |j|j }|j||y|j$s |j&r|j(j||y|j*rNdd lm} | |j|j |j|j }|j||yy) Nr) BaseRegistryr)rrmrqrFinishedJobRegistryrmrurqDeferredJobRegistryStartedJobRegistry)ScheduledJobRegistryr)rrrr rrmrqremoverrr1rrrrremove_executionsrrrrrrr) rgrrrr rrrrrrrs r*rzJob._remove_from_registriess*  $4;;4??t_A HHTHH -    5* 4>>^b^m^mH OOD8O 4    5* 4>>^b^m^mH OOD8O 4 __ 4* 4>>^b^m^mH  & &th & ? OOD8O 4    6+ 4>>^b^m^mH OOD8O 4 ^^t  $ $ + +D8 + D    5* 4>>^b^m^mH OOD8O 4 r)delete_dependentsc||n |j}|j|||r|j||jj |||j rIddlm}|j|j |j}|j|j||j |j|j|jy)aCancels the job and deletes the job hash from Redis. Jobs depending on this job can optionally be deleted as well. Args: pipeline (Optional[Pipeline], optional): Redis' piepline. Defaults to None. remove_from_queue (bool, optional): Whether the job should be removed from the queue. Defaults to True. delete_dependents (bool, optional): Whether job dependents should also be deleted. Defaults to False. Nrr)rarr)Group)rmrrrdeletergrouprrr delete_jobrrrrM)rgrrrrmrrs r*rz Job.deletes"*!5X4??  $$hJ[$\   " "H " 5 &&4*&E == $KK t?E   TWWx  8$((D$7$79N9NOr)c||n |j}|jD]B} tj||j|j}|j |dD|j |jy#t $rYlwxYw)zDelete jobs depending on this job. Args: pipeline (Optional[Pipeline], optional): Redis' piepline. Defaults to None. NrpFr)rmrrXrrrqrr-r)rgrrm dependent_idras r*rzJob.delete_dependentss "*!5X4??  .. L ii UYUdUdie H F  $--."  s?A>> B  B c$|jj|jtj | |j |_|tjusJ|j S#|tjusJwxYw)zThe main execution method. Invokes the job function with the job arguments. This is the method that actually performs the job - it's what its called by the worker. Returns: result (Any): The job result )rmpersistrrzpush_executerpoprs r*performz Job.perform)sp ) ,==?DL:>>++ ++||:>>++ ++s A55Brc$||_t|_|j|_tj |_t|j|j t|j|d}|j|j|y)a#Prepares the job for execution, setting the worker name, heartbeat information, status and other metadata before execution begins. Args: worker_name (str): The worker that will perform the job pipeline (Pipeline): The Redis' piipeline to use )rrrrr}N) rr8rrr=rJrr;rr)rgrrr~s r*prepare_for_executionzJob.prepare_for_execution8sq'!e-- (( '(;(;<ll#DOO4&    dhh 0r)c|j|ji|j}tj|r'tj }|j |}|S|S)auActually runs the function with it's *args and **kwargs. It will use the `func` property, which was already resolved and ready to run at this point. If the function is a coroutine (it's an async function/method), then the `result` will have to be awaited within an event loop. Returns: result (Any): The function result )rrrasyncio iscoroutinenew_event_looprun_until_complete)rgrZloop coro_results r*rz Job._executeLsXDII55   v &))+D11&9K  r) default_ttlc6|j|S|jS)aRReturns ttl for a job that determines how long a job will be persisted. In the future, this method will also be responsible for determining ttl for repeated jobs. Args: default_ttl (Optional[int]): The default time to live for the job Returns: ttl (int): The time to live )rrgrs r*get_ttlz Job.get_ttl\s#hh.{!>@S\`\c\c d A  ! !$ @ A A As A88Bch|jsytjd|j ||jt |j5|j||j g|dddy#1swYyxYw#t$r"tjd|jwxYw)z/Executes failure_callback with possible timeoutNz Running failure callbacks for %srz.Job %s: error while executing failure callback) rrrrrrrmr exception)rgrrXs r*execute_failure_callbackzJob.execute_failure_callbacks$$  7A $T%B%BDW`d`g`gh H%%%dDOOGhG H H H    Mtww W  s)#BA:1B:B?BB+B1cJtjd|j ||jt|j5|j ||j dddy#1swYyxYw#t$r"tjd|jwxYw)z/Executes stopped_callback with possible timeoutz Running stopped callbacks for %srNz.Job %s: error while executing stopped callback) rrrr rr rmrr)rgrs r*execute_stopped_callbackzJob.execute_stopped_callbacks 7A $T%B%BDW`d`g`gh =%%dDOO< = = =    Mtww W  s)#A7A+"A7+A40A74A77+B"c`|jtj||j }|j |d||jr;ddlm}|j||jj|j|||dk7r |j}|j|||yy) z0Saves and cleanup job after successful executionrF)rrwrxrr!)r\rrrN) rr=rHrTrrr"rrr[rrr)rgrrrxr"rs r*_handle_successzJob._handle_successs  **X>"888 8% W  & & ' FMM$ 6 6T\\Walt u ?$($>$> ! ! % %dJ A r)rVc|j}|j }|j||j||||jr'ddlm}|j ||j||yy)N)rrVr_save_exc_to_jobrr!)rVr)rrTrrrr"create_failure)rgrVrrrr"s r*_handle_failurezJob._handle_failuresw"66 $:::   !-    & & ' !F ! !$(8(8ZZb c 'r)c|jr%ddlm}|j||j||j sdn|j dz|_|j ||y)Nrr!r)rTrr"create_retriedrr _enqueue_job)rgrrr"s r*_handle_retry_resultzJob._handle_retry_resultsY  & & ' !F ! !$(8(88 L*.*@*@dF\F\_`F` 4(3r)c|jyt|j}|jsJt||jz d}|j|S)zReturns the desired retry interval. If number of retries is bigger than length of intervals, the first value in the list will be used multiple times. Returns: retry_interval (int): The desired retry interval r)rrermax)rgnumber_of_intervalsindexs r*get_retry_intervalzJob.get_retry_intervals\    '!$"6"67    '$*;*;;Q?##E**r)c@|jduxr|jdkDS)Nr)rrs r* should_retryzJob.should_retrys#!!-G$2C2Ca2GHr)c|j}|jsJ|jdz |_|rtjtj t |z}|jtj|j|||tjd|j||jy|j||tjdy)aRequeue or schedule this job for execution. If the the `retry_interval` was set on the job itself, it will calculate a scheduled time for the job to run, and instead of just regularly `enqueing` the job, it will `schedule` it. Args: queue (Queue): The queue to retry the job on pipeline (Pipeline): The Redis' pipeline to use r)secondsrz/Job %s: scheduled for retry at %s, %s remainingz(Job %s: enqueued for retry, %s remainingN)rrrr8rutcrrr=rL schedule_jobrinforr)rgrrretry_intervalscheduled_datetimes r*retryz Job.retrys002     --1 !)hll!;iP^>_!_  OOI// 0   t%7(  K KKA477L^`d`q`q    th  7 KKB Cr)cddlm}||j|j|j|j }|j |||j||n |j}|jD]K}|j|}|j||j|j|j|My)a&Jobs may have dependencies. Jobs are enqueued only if the jobs they depend on are successfully performed. We record this relation as a reverse dependency (a Redis set), with a key that looks something like: ..codeblock:python:: rq:job:job_id:dependents = {'job_id_1', 'job_id_2'} This method adds the job in its dependencies' dependents sets, and adds the job to DeferredJobRegistry. Args: pipeline (Optional[Pipeline]): The Redis' pipeline. Defaults to None rrr)rrN) rrrrmr1rqrrrrIsaddrrM)rgrrrrmrPrs r*register_dependencyzJob.register_dependency.s 2& KKDOOt~~Z^ZiZi   TH$(( ;!)!5X4?? !11 BM!44]CN OONDGG 4 OOD11= A Br)c|jj|j}|Dcgc]%}tj |j 'c}Scc}wr])rmrrMrXr!rm)rgrfrs r*rfzJob.dependency_idsKs?//0E0EF 5ABc CJJL)BBBs*A parent_jobrc ||n |j}|6|j|jDcgc]}|j|c}|j |j Dchc]}|j }}|r$|j||r|j|k(rd}|rj|j|j|jtjk(ry|jtjk(r |jsy|sy|j5}|D]#}|j!|j|d%|j#} dddtj$g |jr j'tjt) fd DScc}wcc}w#1swYcxYw)aeReturns a boolean indicating if all of this job's dependencies are `FINISHED` If a pipeline is passed, all dependencies are WATCHed. `parent_job` allows us to directly pass parent_job for the status check. This is useful when enqueueing the dependents of a _successful_ job -- that status of `FINISHED` may not be yet set in redis, but said job is indeed _done_ and this method is _called_ in the _stack_ of its dependents are being enqueued. Args: parent_job (Optional[Job], optional): The parent Job. Defaults to None. 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. Returns: are_met (bool): Whether the dependencies were met. NFTrc3HK|]}|s|jvywr])rm)r`rallowed_statusess r*rbz+Job.dependencies_are_met..s e6^d6==?&66es"")rmrNrr!rrMrmdiscardrrr=rNrrIrrrr)rHr+rc) rgrrrrmrPrdependencies_idsrdependencies_statusesrs @r*dependencies_are_metzJob.dependencies_are_metPs."*!5X4??   J  PTPdPde}t||M:e f4>4G4GH]H]4^_SCJJL__   $ $^ 4jmm~=!   $ $Z]] 3$$&)*<*<<##y'7'77@^@^$  " 7h' ; dll3/: ;%-$4$4$6 !  7 &../  ) )  # #I$4$4 5eEZeeeCf_* 7 7sF3'F8"9F==G)NNN)NNNNNNNNNNrNNNN)Tr]NNNF)FN)Fr)TT)NTT)rPr)NT)NTF)NNT)rr rr)vr%r&r'rFr__annotations__rEr_ri classmethodr0rrrr rrnr=r1r rrrjrrrpropertyrrrrrrrrrrr rrrrrrr r rrsetterrrrrr"rrr r/r2r4r7r:r<rrrBrbytesr!rIrrrMrRrXr\rZrrUr,rrr{rrTrrrrsr~rrrrrrrrrrr5rrrrrrrrrrrrrrrrrfrr(r)r*rXrXsu R% !*358C=35Xg=N35j.2+/(,$(!&*%)26!% )-%)"&#a&GKFJFJ+a#auT5[)*ac3h( a W% a SM ac]a#ac]a./a#a SMaatCH~&ac]a"3-#a&U:xS/A#ABC'a(U:xS/A#ABC)a*U:xS/A#ABC+a, -aaF hsm $(92E& : :hz6J :VZ :   7T77545554556D667T777T778d886D66++ HUO  QtCyQQ 00&&.#.. &&.#.. &&.#.. 0$ [[## !! __!!eD%K(  [[!!S#X  ]]!!  C  W      s(9V[ #GY]^fgl^mYnBk[I   C D  T8 T# T*AU Tbf T && !B IS IU I I R R R R%%00WW@T`dej`k4(3-"DXc]B"""H<h< VS V(1C VR73R7j LDLLQUL\.Xj1..ei.(<<< )%S# *> )5 5x 35PT5n I I IFF 8[ 18650D65`d65rpuP ,PHLPhlP4/(:*>/"  11 1(# =8C= =HSM = K# K# K#:8C=:8J;O:ko:.       ADAQN r)rPct|jtr |jSdj|jj|jj S)Nr)r^rr_rr&r'rs r*rz Callback.namesA dii %99  4 4dii6L6LMMr)r]) r%r&r'rr_r rrrirrr(r)r*rrsMOU3c(:#:;OhsmONcNNr)rrrr])Wrrrologgingrwrirrrenumrtypingrrr r r r r rrrruuidrredisrdefaultsrrtimeoutsrr _typeshedrr redis.clientrtyping_extensionsrrrrrr rr"r$ exceptionsr+r,r-localr. serializersr/typesr0r1utilsr2r3r4r5r6r7r8r9r:r; getLoggerrr_r=rTrVobjectrkrrjrtr|rrXrzrrr(r)r*r&s`  22llllK;!%(8  RQ+;      8 $ T cc116"( ) rs r rVZ r 1Xe_`hin`o$   e ufufp/\ 7 7 t N Nr)