&jD $%SrSSKrSSKJr SSKJr SSKJ r SSK J r J r JrJrJrJrJr SSKJrJr SSKJrJr "S S \5r"S S \5r\"5S \"5SS/0SS.r\\S'S'S\\SS4SjjrS(S\SS4Sjjr S)S\!SS4Sjjr"S'S\\S\\\\\444Sjjr#S*S\S\\S\\SS4Sjjr$S\ S\ 4S\ S\\\\444Sjr%S\\\\44S jr&S\\\\44S!jr'S+S"\(S\!4S#jjr)S,S$\ S%\ SS4S&jjr*g)-z0.0.12N)wraps)exit)_exit)AnyCallableDictListOptional TypedDictUnion)Thread Semaphore)Process cpu_countc^\rSrSr%Sr\\\S'\\ \ \ \ 4\S'\ \S'\ \S'Srg) PoolConfig$zType definition for execution pool configuration. This defines the structure of each pool in the POOLS dictionary, containing the semaphore for limiting concurrent tasks, the engine type (Thread or Process), pool name, and thread count. poolenginenamethreadsN)__name__ __module__ __qualname____firstlineno____doc__r r__annotations__r typer rstrint__static_attributes__rf/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/multitasking/__init__.pyrr$s6 9  $v,W - .. I Lr#rc\rSrSr%Sr\\S'\\S'\\S'\\S'\\S'\ \ \ \ 4\S'\ \\4\S '\\S 'S rg ) Config1zType definition for global multitasking configuration. This structure holds all global state including CPU info, engine preferences, task tracking, and pool management. It serves as the central configuration store for the entire library. CPU_CORESENGINE MAX_THREADSDAEMON KILL_RECEIVEDTASKSPOOLS POOL_NAMErN)rrrrrr!rr boolr r r rrrr"rr#r$r&r&1sL N K L fgo& '' Z  Nr#r&threadFMain)r(r)r*r+r,r-r.r/configrreturnc@Ub U[S'g[5[S'g)aConfigure the maximum number of concurrent threads/processes. This function allows users to override the default CPU-based thread count. Setting this affects new pools but not existing ones. Args: threads: Maximum concurrent tasks. If None, uses CPU count. Must be positive integer or None. Example: set_max_threads(4) # Limit to 4 concurrent tasks set_max_threads() # Reset to CPU count Nr*)r3r)rs r$set_max_threadsr6Ts" '}!* }r#kindcRSUR5;a S[S'gS[S'g)aConfigure the execution engine for new pools. This determines whether new tasks run in threads or separate processes. Threads share memory but processes are more isolated. Only affects pools created after this call. Args: kind: Engine type. Contains "process" for multiprocessing, anything else defaults to threading. Note: Threading: Faster startup, shared memory, GIL limitations Processing: Slower startup, isolated memory, true parallelism processr)r1N)lowerr3)r7s r$ set_enginer;js(DJJL $x$xr#daemonc([U5[S'g)uBConfigure whether new tasks spawn as daemon threads/processes. Daemon tasks are terminated automatically when the interpreter exits; non-daemon tasks block interpreter exit until they finish (the long-standing default, which lets ``wait_for_tasks`` or a plain script-end serve as an implicit join point). Call this once, alongside :func:`set_engine`, when your code contains long-lived ``@task`` workers (schedulers, pollers, infinite cleanup loops) that must NOT block process exit — for example in test suites, CLIs that shut down on SIGTERM, or any application where tasks are fire-and-forget by design. Args: daemon: True to spawn daemon tasks, False to preserve the historical non-daemon behavior (default). Note: This setting affects only tasks spawned after the call. Existing tasks retain whatever daemon flag they were created with. Also affects Processes as well as Threads; for Processes the daemon flag additionally prevents them from spawning child processes of their own. Example: import multitasking multitasking.set_engine("thread") multitasking.set_daemon(True) # long-lived worker opt-in @multitasking.task def cleanup(): while True: do_cleanup() time.sleep(60) cleanup() # fires and forgets; exits cleanly with the process r+N)r0r3)r<s r$ set_daemonr>sNF|F8r#rcUc [SnSn[S[SS[:XaSnUU[S[SSS.$)anRetrieve information about an execution pool. Returns a dictionary with pool metadata including engine type, name, and thread count. Useful for debugging and monitoring. Args: name: Pool name to query. If None, uses current active pool. Returns: Dictionary with keys: 'engine', 'name', 'threads' Raises: KeyError: If the specified pool doesn't exist r/r1r.rr9r)rrr)r3r)rrs r$getPoolr@sb  |k"F gvk*+H5@'?6+#67 B r#rcbU[S'Ub [U5O[SnUS:aSnUbUO[SnU[S'U[S'US:a [ U5OSSUR 5;a[ O[UUS.[S [S'g![[4a [SnNf=f) adCreate a new execution pool with specified configuration. Pools manage concurrent task execution using semaphores. Each pool has its own thread/process limit and engine type. Creating a pool automatically makes it the active pool for new tasks. Args: name: Unique identifier for this pool threads: Max concurrent tasks. None uses global MAX_THREADS. Values < 2 create unlimited pools (no semaphore). engine: "process" or "thread". None uses global ENGINE setting. Note: Setting threads=0 or threads=1 creates an unlimited pool where all tasks run immediately without queuing. r/Nr*rr)r9)rrrrr.)r3r! ValueError TypeErrorrr:rr )rrrs r$ createPoolrEs,F;(#/CL & {)Vvh/?F$F=F8 '.k '"t&&,,.8'f ,F7OF;'(!  "('(sBB.-B.callee.c ^^[S(d [5 S[S[S[4U4Sjjm[T5S[S[S[[ [ [44UU4Sjj5nU$)uSDecorator that converts a function into an asynchronous task. This is the main decorator of the library. It wraps any function to make it run asynchronously in the background using the current pool's configuration (threads or processes). The spawned Thread/Process inherits its ``daemon`` flag from the global :data:`config` via :func:`set_daemon` — by default tasks are non-daemon (Python waits for them on interpreter exit). For fire-and-forget background workers, call ``multitasking.set_daemon(True)`` once before declaring the task. Args: callee: The function to be made asynchronous Returns: Decorated function that returns Thread/Process object or None Example: @task def my_function(x, y): return x + y result = my_function(1, 2) # Returns Thread/Process object wait_for_tasks() # Wait for completion r.argskwargsr4c>[S[SSnUbU T"U0UD6sSSS5 $T"U0UD6$!,(df  g=f)aInternal wrapper that handles semaphore-controlled execution. This function is what actually runs in the background thread/process. It acquires the pool's semaphore (if any) before executing the original function, ensuring we don't exceed the concurrent limit. r.r/rNr3)rHrIrrFs r$ _run_via_pooltask.._run_via_pool$sTgvk23F;  t.v.4*6* * s 7 Ac:>[S[SSS:Xa T"U0UD6 g[S(dQ[S[SSnU"TUU[SS 9n[S RU5 UR5 U$g![a W"TUUS 9nN?f=f) zThe actual decorated function that users call. This decides whether to run synchronously (for 0-thread pools) or asynchronously (for normal pools). It handles the creation and startup of Thread/Process objects. r.r/rrNr,rr+)targetrHrIr<)rOrHrIr-)r3 Exceptionappendstart)rHrI engine_classsinglerLrFs r$ async_methodtask..async_method4s '?6+. / :a ? D #F #o& %gvk/BCHM &(!!(+  7O " "6 * LLNM% %(! s&BBB)r3rErrr r r r)rFrUrLs` @r$taskrWsr< '? +S+C+C+  6]44!4 %( )44l r#c[S$)ayRetrieve all tasks ever created by this library. This includes both currently running tasks and completed ones. Useful for debugging and monitoring task history. Returns: List of all Thread/Process objects created by @task decorator Note: Completed tasks remain in this list until program termination. Use get_active_tasks() to see only currently running tasks. r-rKrr#r$get_list_of_tasksrYns '?r#cl[SVs/sHoR5(dMUPM sn$s snf)akRetrieve only the currently running tasks. Filters the complete task list to show only tasks that are still executing. This is more useful than get_list_of_tasks() for monitoring current system load. Returns: List of Thread/Process objects that are still running Example: active = get_active_tasks() print(f"Currently running {len(active)} tasks") r-)r3is_alive)rWs r$get_active_tasksr\~s&$G_ @_T D_ @@ @s11sleepcS[S'[S[SSS:Xag[SVs/sH!nUcMUR5(dMUPM# nnUHnURS5 M [[SVs/sH!nUcMUR5(dMUPM# sn5nUS:XaOUS:a[R "U5 MS [S'gs snfs snf![ a N f=f) a'Block until all background tasks complete execution. This is the primary synchronization mechanism. It prevents new tasks from being created and waits for existing ones to finish. Essential for ensuring all work is done before program exit. Args: sleep: Seconds to sleep between checks. 0 means busy-wait. Higher values reduce CPU usage but increase latency. Returns: Always returns True when all tasks are complete Note: Sets KILL_RECEIVED=True during execution to prevent new tasks, then resets it to False when done. Tr,r.r/rrr-F)r3r[joinlen_timer]rP)r]rW running_tasks still_runnings r$wait_for_tasksres&#F?gvk*+I6!; "(!0(,  & ! & !'!!0(, !M !qy E"1>$F? =!    sK C.C$C$C$,C.C)C)(C). C.<C.$ C.. C;:C;selfclscvS[S'[S5 S[S'g![a [S5 N!f=f)aEmergency shutdown function that terminates the entire program. This is a last-resort function that immediately exits the program, potentially leaving tasks in an inconsistent state. It tries sys.exit() first, then os._exit() as a final measure. Args: self: Unused parameter kept for backward compatibility cls: Unused parameter kept for backward compatibility Warning: This function does NOT wait for tasks to complete cleanly. Use wait_for_tasks() for graceful shutdown instead. Note: The function attempts sys.exit(0) first (which allows cleanup handlers to run), falling back to os._exit(0) which terminates immediately without any cleanup. Tr,rFN)r3sysexit SystemExitosexit)rfrgs r$killallrls>*#F? $F? q s 88)N))F)mainNN)r)NN)+ __version__timerb functoolsrsysrriosrrktypingrrrr r r r threadingr rmultiprocessingrrrr&r3rr!r6r r;r0r>r@rErWrYr\floatrerlrr#r$rxs,h HHH(.  Y(;      ,Xc],d,,$S$$$.'$t'$'$T(3-4U38_0D+EB! 5 5 c]5 SM5 5ph S#X h c8E&'/2334hV 4fgo 67  A$uVW_56A";%;;|$#$3$$$r#