o 0׾gP@s2dZddlmZddlmZddlZgdZejdZGddde Z Gd d d e Z d[d d Z d dZiZddZddZddZddZddZeZddZddZddZGdd d eZ    ! ! !d\d"d#Zd$d%Z    ! ! !d\d&d'Zd(d)Zd*d+Zd,d-Z ed]d.d/Z!ed0d1Z"ed2d3Z#ed4d5Z$ed6d7Z%d8d9Z&e ! ! d^d:d;Z'ed_dd?Z)d`dAdBZ*edadCdDZ+edbdEdFZ,edbdGdHZ-edIdJZ.edKdLZ/edMdNZ0dOdPZ1dQdRZ2 ! ! ! !dcdTdUZ3dVdWZ4dXdYZ5e5de4_e6dZkre4dSdS)da= Make the standard library cooperative. The primary purpose of this module is to carefully patch, in place, portions of the standard library with gevent-friendly functions that behave in the same way as the original (at least as closely as possible). The primary interface to this is the :func:`patch_all` function, which performs all the available patches. It accepts arguments to limit the patching to certain modules, but most programs **should** use the default values as they receive the most wide-spread testing, and some monkey patches have dependencies on others. Patching **should be done as early as possible** in the lifecycle of the program. For example, the main module (the one that tests against ``__main__`` or is otherwise the first imported) should begin with this code, ideally before any other imports:: from gevent import monkey monkey.patch_all() A corollary of the above is that patching **should be done on the main thread** and **should be done while the program is single-threaded**. .. tip:: Some frameworks, such as gunicorn, handle monkey-patching for you. Check their documentation to be sure. .. warning:: Patching too late can lead to unreliable behaviour (for example, some modules may still use blocking sockets) or even errors. .. tip:: Be sure to read the documentation for each patch function to check for known incompatibilities. Querying ======== Sometimes it is helpful to know if objects have been monkey-patched, and in advanced cases even to have access to the original standard library functions. This module provides functions for that purpose. - :func:`is_module_patched` - :func:`is_object_patched` - :func:`get_original` .. _plugins: Plugins and Events ================== Beginning in gevent 1.3, events are emitted during the monkey patching process. These events are delivered first to :mod:`gevent.events` subscribers, and then to `setuptools entry points`_. The following events are defined. They are listed in (roughly) the order that a call to :func:`patch_all` will emit them. - :class:`gevent.events.GeventWillPatchAllEvent` - :class:`gevent.events.GeventWillPatchModuleEvent` - :class:`gevent.events.GeventDidPatchModuleEvent` - :class:`gevent.events.GeventDidPatchBuiltinModulesEvent` - :class:`gevent.events.GeventDidPatchAllEvent` Each event class documents the corresponding setuptools entry point name. The entry points will be called with a single argument, the same instance of the class that was sent to the subscribers. You can subscribe to the events to monitor the monkey-patching process and to manipulate it, for example by raising :exc:`gevent.events.DoNotPatch`. You can also subscribe to the events to provide additional patching beyond what gevent distributes, either for additional standard library modules, or for third-party packages. The suggested time to do this patching is in the subscriber for :class:`gevent.events.GeventDidPatchBuiltinModulesEvent`. For example, to automatically patch `psycopg2`_ using `psycogreen`_ when the call to :func:`patch_all` is made, you could write code like this:: # mypackage.py def patch_psycopg(event): from psycogreen.gevent import patch_psycopg patch_psycopg() In your ``setup.py`` you would register it like this:: from setuptools import setup setup( ... entry_points={ 'gevent.plugins.monkey.did_patch_builtins': [ 'psycopg2 = mypackage:patch_psycopg', ], }, ... ) For more complex patching, gevent provides a helper method that you can call to replace attributes of modules with attributes of your own modules. This function also takes care of emitting the appropriate events. - :func:`patch_module` .. _setuptools entry points: http://setuptools.readthedocs.io/en/latest/setuptools.html#dynamic-discovery-of-services-and-plugins .. _psycopg2: https://pypi.python.org/pypi/psycopg2 .. _psycogreen: https://pypi.python.org/pypi/psycogreen Use as a module =============== Sometimes it is useful to run existing python scripts or modules that were not built to be gevent aware under gevent. To do so, this module can be run as the main module, passing the script and its arguments. For details, see the :func:`main` function. .. versionchanged:: 1.3b1 Added support for plugins and began emitting will/did patch events. )absolute_import)print_functionN) patch_allpatch_builtins patch_dnspatch_os patch_queue patch_select patch_signal patch_socket patch_sslpatch_subprocess patch_sys patch_thread patch_time get_originalis_module_patchedis_object_patched patch_modulemainwinc@seZdZdZddZdS)_BadImplementsz6 Raised when ``__implements__`` is incorrect. cCst|d|fdS)Nz7Module %r has a bad or missing value for __implements__)AttributeError__init__)selfmodulerW/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/monkey.pyrsz_BadImplements.__init__N)__name__ __module__ __qualname____doc__rrrrrrs rc@seZdZdZdS)MonkeyPatchWarningzE The type of warnings we issue. .. versionadded:: 1.3a2 N)rrr r!rrrrr"sr"cCsddlm}||_||dS)Nr)notify_and_call_entry_points) gevent.eventsr# _warnings)eventr%r#rrr _notify_patchs  r'cs$ddlm}|fdd}|S)Nr)wrapscs2ddlm}z|i|WS|yYdSw)Nr) DoNotPatchF)r$r))argskwargsr)funcrrignoress  z$_ignores_DoNotPatch..ignores) functoolsr()r-r(r.rr,r_ignores_DoNotPatchs r0cCs|tvS)z Check if a module has been replaced with a cooperative version. :param str mod_name: The name of the standard library module, e.g., ``'socket'``. )saved)mod_namerrrrsrcCst|o |t|vS)a$ Check if an object in a module has been replaced with a cooperative version. :param str mod_name: The name of the standard library module, e.g., ``'socket'``. :param str item_name: The name of the attribute in the module, e.g., ``'create_connection'``. )rr1)r2 item_namerrrrs rcCsttSN)boolr1rrrris_anything_patcheds r6cCsZt|i}g}d}|D]}||vr|||q |dur"t|}|t||q |Sr4)r1getappend __import__getattr)nameitemsdvaluesritemrrr _get_originals r@c Cst|tr|gn|}t|tr|g}d}n|}d}|D]%}zt||}Wnty4||dur2Yqw|r=|dS|SdS)a Retrieve the original object from a module. If the object has not been patched, then that object will still be retrieved. :param str mod_name: The name of the standard library module, e.g., ``'socket'``. Can also be a sequence of standard library modules giving alternate names to try, e.g., ``('thread', '_thread')``; the first importable module will supply all *item_name* items. :param item_name: A string or sequence of strings naming the attribute(s) on the module ``mod_name`` to return. :return: The original value if a string was given for ``item_name`` or a sequence of original values if a sequence was passed. TFrN) isinstancestrr@ ImportError)r2r3 mod_names item_namesunpackmodresultrrrrs    rcCs:t||t}|turt|ji||t|||dSr4)r:_NONEr1 setdefaultrsetattr)rattrnewitemolditemrrr patch_item"s rPcCs<t||t}|tur dSt|ji||t||dSr4)r:rJr1rKrdelattr)rrMrOrrr remove_item)s rRcsRfdd}d|d}zt||}Wn ty dd}Ynw||||dS)Ncst|dSr4)_queue_warning)messager%rrwarn4sz __call_module_hook..warn_gevent_ _monkey_patchcWsdSr4r)r*rrr;z$__call_module_hook..)r:r) gevent_moduler;rr<r%rV func_namer-rrUr__call_module_hook1s    r]c@s,eZdZeeZddZddZddZdS)_GeventDoPatchRequestcCs ||_||_||_|p i|_dSr4) target_module source_moduler< patch_kwargs)rr_r`r<rarrrrEsz_GeventDoPatchRequest.__init__cCs&|jD] }t|j|t|j|qdSr4)r<rPr_r:r`)rrMrrrdefault_patch_itemsOs z)_GeventDoPatchRequest.default_patch_itemscGs2t|tr |f|}|j}|D]}t||qdSr4)rBrCr_rR)rr_r<r?rrrrRSs   z!_GeventDoPatchRequest.remove_itemN)rrr staticmethodrrrbrRrrrrr^As  r^Tc Csddlm}|durt|dd}|durt|z|r#t|d||||r1t||j||||Wn |jy=YdSwt|dt j } t ||||} | | |rZt|d||||rft| |j||d S) aU patch_module(target_module, source_module, items=None) Replace attributes in *target_module* with the attributes of the same name in *source_module*. The *source_module* can provide some attributes to customize the process: * ``__implements__`` is a list of attribute names to copy; if not present, the *items* keyword argument is mandatory. ``__implements__`` must only have names from the standard library module in it. * ``_gevent_will_monkey_patch(target_module, items, warn, **kwargs)`` * ``_gevent_did_monkey_patch(target_module, items, warn, **kwargs)`` These two functions in the *source_module* are called *if* they exist, before and after copying attributes, respectively. The "will" function may modify *items*. The value of *warn* is a function that should be called with a single string argument to issue a warning to the user. If the "will" function raises :exc:`gevent.events.DoNotPatch`, no patching will be done. These functions are called before any event subscribers or plugins. :keyword list items: A list of attribute names to replace. If not given, this will be taken from the *source_module* ``__implements__`` attribute. :return: A true value if patching was done, a false value if patching was canceled. .. versionadded:: 1.3b1 reventsN__implements__willF_gevent_do_monkey_patchdidT) geventrer:rr]r'GeventWillPatchModuleEventrr)r^rbGeventDidPatchModuleEvent) r_r`r<r% _patch_kwargs_notify_will_subscribers_notify_did_subscribers _call_hooksredo_patchrequestrrrr\sF !   rcCs0ttd||}t|d|}t|}|||fS)z Test that the source and target modules for *name* are available and return them. :raise ImportError: If the source or target cannot be imported. :return: The tuple ``(gevent_module, target_module, target_module_name)`` gevent. __target__)r:r9)r;r[target_module_namer_rrr_check_availabilitys  rvc Cst|\}}} t||||||||dt|dd} | D]'} tj| } | durB| |urBt| dt| |||ddddt| t| <q||fS)N)r<r%rmrnrorp__alternate_targets__rF)r<r%rnrorp)rvrr:sysmodulesr7r1pop) r;r<r%rmrnrorpr[r_rualternate_namesalternate_namealternate_modulerrr _patch_modules*    r~cCs$|dur t|gdS||dSr4)_process_warningsr8)rTr%rrrrSsrScCs&ddl}|D] }|j|tddqdS)Nr) stacklevel)warningsrVr")r%rwarningrrrrsrcCs8ddlm}tt|}t||stt|||dSdS)Nr)FileObjectThread)gevent.fileobjectrr:rxrBrP)r;rorigrrr_patch_sys_stds   rcCdS)a Patch sys.std[in,out,err] to use a cooperative IO via a threadpool. This is relatively dangerous and can have unintended consequences such as hanging the process or `misinterpreting control keys`_ when :func:`input` and :func:`raw_input` are used. :func:`patch_all` does *not* call this function by default. This method does nothing on Python 3. The Python 3 interpreter wants to flush the TextIOWrapper objects that make up stderr/stdout at shutdown time, but using a threadpool at that time leads to a hang. .. _`misinterpreting control keys`: https://github.com/gevent/gevent/issues/274 .. deprecated:: 23.7.0 Does nothing on any supported version. Nr)stdinstdoutstderrrrrrsrcC tddS)a^ Replace :func:`os.fork` with :func:`gevent.fork`, and, on POSIX, :func:`os.waitpid` with :func:`gevent.os.waitpid` (if the environment variable ``GEVENT_NOWAITPID`` is not defined). Does nothing if fork is not available. .. caution:: This method must be used with :func:`patch_signal` to have proper `SIGCHLD` handling and thus correct results from ``waitpid``. :func:`patch_all` calls both by default. .. caution:: For `SIGCHLD` handling to work correctly, the event loop must run. The easiest way to help ensure this is to use :func:`patch_all`. osNr~rrrrr s rcCs*ddl}d|jjvrtddgddSdS)z On Python 3.7 and above, replace :class:`queue.SimpleQueue` (implemented in C) with its Python counterpart. .. versionadded:: 1.3.5 rN SimpleQueuequeuer<) gevent.queuer__all__r~)rjrrrrs rcCr)z? Replace :func:`time.sleep` with :func:`gevent.sleep`. timeNrrrrrr,s rcCr)a5 Replaces the implementations of :mod:`contextvars` with :mod:`gevent.contextvars`. On Python 3.7 and above, this is a standard library module. On earlier versions, a backport that uses the same distribution name and import name is available on PyPI (though this is not recommended). If that is installed, it will be patched. .. versionchanged:: 20.04.0 Clarify that the backport is also patched. .. versionchanged:: 20.9.0 This now does nothing on Python 3.7 and above. gevent now depends on greenlet 0.4.17, which natively handles switching context vars when greenlets are switched. Older versions of Python that have the backport installed will still be patched. .. deprecated:: 23.7.0 Does nothing on any supported version. Nrrrrrpatch_contextvars3srcCstt|dkr dS||_z|}Wn ty$|}Ynwt| }zddl }Wnt yBGdddt }Ynw|j j}td}|D]5}t||rwdD]}t||rnt||durlt|||nqXtdt|qOt||r|jdur||_qOdS)Nrc@s eZdZdS)z*_patch_existing_locks.._ModuleLockN)rrr rrrr _ModuleLockcsrgc)_owner _RLock__ownerzEUnsupported Python implementation; Found unknown lock implementation.)lenlist enumerate_allocate_lock_active_limbo_lock get_identr _get_identtypeRLockimportlib._bootstraprDobject _bootstraprr9 get_objectsrBhasattrr:rLAssertionErrorvarsowner) threadingtid rlock_type importlibrro owner_namerrr_patch_existing_locksNsD             rcs|r td}ndd}d}td|dd\}} |r{td|dd\}} |r>ddlm}td|td r>td ||rDt|r{d tj vr{td }t|d  |j D] } t | rc| n| } | durjqZt| d sut d |  | _qZ|rtd}ddlm} t|d| fdd}|rddlm}jD]}||krq||d|_qtd}tdd}j|kr|s|_j_jdusJ_jfdd}td|j j!}"_#|jvrj|jj!<|j!krj|=n|s6t$d|fdd}td|ddl%m&}t'|(d|| t'|(d|dS)aP patch_thread(threading=True, _threading_local=True, Event=True, logging=True, existing_locks=True) -> None Replace the standard :mod:`thread` module to make it greenlet-based. :keyword bool threading: When True (the default), also patch :mod:`threading`. :keyword bool _threading_local: When True (the default), also patch :class:`_threading_local.local`. :keyword bool logging: When True (the default), also patch locks taken if the logging module has been configured. :keyword bool existing_locks: When True (the default), and the process is still single threaded, make sure that any :class:`threading.RLock` (and, under Python 3, :class:`importlib._bootstrap._ModuleLock`) instances that are currently locked can be properly unlocked. **Important**: This is a best-effort attempt and, on certain implementations, may not detect all locks. It is important to monkey-patch extremely early in the startup process. Setting this to False is not recommended, especially on Python 2. .. caution:: Monkey-patching :mod:`thread` and using :class:`multiprocessing.Queue` or :class:`concurrent.futures.ProcessPoolExecutor` (which uses a ``Queue``) will hang the process. Monkey-patching with this function and using sub-interpreters (and advanced C-level API) and threads may be unstable on certain platforms. .. versionchanged:: 1.1b1 Add *logging* and *existing_locks* params. .. versionchanged:: 1.3a2 ``Event`` defaults to True. rNthreadF)r%ror)Eventr_Eventlogging_locklockzUnknown/unsupported handler %r_threading_local)localrcs2ddlmddlmdfdd }|S)Nrsleep)rcszd}ur tddurjrdSsdS|r"|}r;|dur1|kr1dSds&dSdS)NzCannot join current threadg{Gz?)current_thread RuntimeErrordeadis_alive)timeoutend)rrthread_greenlet threading_modrrrjoins  z2patch_thread..make_join_func..joinr4) gevent.hubrr)rrr)r)rrrrrmake_join_funcs   z$patch_thread..make_join_func)main_native_threadgreenlet _shutdowncsjsdSjddlm}z|Wnddlm}|jgtRYd_j _d_ t ddS)Nrr)get_hubFr) _tstate_lockreleaserjrrprint_exceptionrxexc_info _is_stopped__real_tstate_lockrP)rr _greenlet main_thread orig_shutdownrrrrHs    zpatch_thread.._shutdownz`Monkey-patching not on the main thread; threading.main_thread().join() will hang from a greenletcs _tddS)Nr)r_identrPr)rrrrrr~s rd))r9rr~ gevent.eventrrPrrrxryr _handlerListcallable TypeErrorr gevent.localrgevent.threadingr_activer>rrrr getcurrentrrrLockacquire _danglingremoveidentrrrSrjrer'rl)rrrrexisting_locksr%orig_current_threadgevent_threading_modgevent_thread_mod thread_mod_wrhandlerrrrrralready_patchedroldidrerrrrsE              &           rcCs\ddlm}|r |j}n t|jt|j}td|d|r*d|jvr,t|ddSdSdS)z Replace the standard socket object with gevent's cooperative sockets. :keyword bool dns: When true (the default), also patch address resolution functions in :mod:`socket`. See :doc:`/dns` for details. rsocketrrsslN)rjrrfset__dns__r~rR)dns aggressiverr<rrrr s   r cCsddlm}td|jddS)z Replace :doc:`DNS functions ` in :mod:`socket` with cooperative versions. This is only useful if :func:`patch_socket` has been called and is done automatically by that method if requested. rrrrN)rjrr~rrrrrrs rrcCstd}t}t}dd}||D]9}t|tr8d|vr8|d|vr%q|D] }||ur6|||q)qt|trL||jvrLd|j vrL||q||fS)NrcSs|d|ddfS)Nr__file__z )r7)rHrrrreportsz!_find_module_refs..reportrrs) r9r get_referrersrBdictr>addr __bases__r)toexcluding_namesrdirect_ref_modulessubclass_modulesrrvrrr_find_module_refss"   rc Cs|odtjvottjdd}td|d\}}|rKt|jdd\}}|s&|rMd}}|r5ddd |D}|r@d d d |D}td |||d Sd Sd S)z patch_ssl() -> None Replace :class:`ssl.SSLSocket` object and socket wrapping functions in :mod:`ssl` with cooperative versions. This is only useful if :func:`patch_socket` has been called. r SSLContextrU)rz gevent.sslz gevent._ssl3zgevent._sslgte279)rz3Modules that had direct imports (NOT patched): %s. cSsg|] \}}d||fqS)z%s (%s)r).0r;fnamerrr s zpatch_ssl..zSubclasses (NOT patched): %s. cSsg|]}t|qSr)rC)rtrrrrsaMonkey-patching ssl after ssl has already been imported may lead to errors, including RecursionError on Python 3.6. It may also silently lead to incorrect behaviour on Python 3.7. Please monkey-patch earlier. See https://github.com/gevent/gevent/issues/1016. N)rxryrr~rorig_SSLContextrS) r% _first_timemay_need_warning gevent_modrrrdirect_ref_mod_str subclass_strrrrr s>   r cCstdd|iddS)a Replace :func:`select.select` with :func:`gevent.select.select` and :func:`select.poll` with :class:`gevent.select.poll` (where available). If ``aggressive`` is true (the default), also remove other blocking functions from :mod:`select` . - :func:`select.epoll` - :func:`select.kqueue` - :func:`select.kevent` - :func:`select.devpoll` (Python 3.5+) selectrrmNrrrrrr s r cCs6ztdWn tyYdSwtdd|iddS)a Replace :class:`selectors.DefaultSelector` with :class:`gevent.selectors.GeventSelector`. If ``aggressive`` is true (the default), also remove other blocking classes :mod:`selectors`: - :class:`selectors.EpollSelector` - :class:`selectors.KqueueSelector` - :class:`selectors.DevpollSelector` (Python 3.5+) On Python 2, the :mod:`selectors2` module is used instead of :mod:`selectors` if it is available. If this module cannot be imported, no patching is done and :mod:`gevent.selectors` is not available. In :func:`patch_all`, the *select* argument controls both this function and :func:`patch_select`. .. versionadded:: 20.6.0 selectorsNrr)rvrDr~rrrrpatch_selectorss   rcCr)a= Replace :func:`subprocess.call`, :func:`subprocess.check_call`, :func:`subprocess.check_output` and :class:`subprocess.Popen` with :mod:`cooperative versions `. .. note:: On Windows under Python 3, the API support may not completely match the standard library. subprocessNrrrrrr 6s r cCr)a Make the builtin :func:`__import__` function `greenlet safe`_ under Python 2. .. note:: This does nothing under Python 3 as it is not necessary. Python 3 features improved import locks that are per-module, not global. .. _greenlet safe: https://github.com/gevent/gevent/issues/108 .. deprecated:: 23.7.0 Does nothing on any supported platform. NrrrrrrDrZrcCr)a Make the :func:`signal.signal` function work with a :func:`monkey-patched os `. .. caution:: This method must be used with :func:`patch_os` to have proper ``SIGCHLD`` handling. :func:`patch_all` calls both by default. .. caution:: For proper ``SIGCHLD`` handling, you must yield to the event loop. Using :func:`patch_all` is the easiest way to ensure this. .. seealso:: :mod:`gevent.signal` signalNrrrrrr Ts r cKsg}d}|d=t|i}| }|s||krtd|i}|D]\}}||vr2|||<||<q!|r@||s@d||<||<q!|||fS)N'_gevent_saved_patch_all_module_settingsr+zUPatching more than once will result in the union of all True parameters being patchedT)r1rKrSr<)module_settingsr%keycurrently_patched first_timeto_patchkrrrr_check_repatchingds"    rcCs0|dr|ds|j}td|dSdSdS)NrrzPatching signal but not os will result in SIGCHLD handlers installed after this not being called and os.waitpid may not function correctly if gevent.subprocess is used. This may raise an error in the future.)will_patch_moduler%rS)will_patch_allrrrr_subscribe_signal_os|s rFcKsDtd it\}}}|st|dS|D] \}}|t|<qddlm}z t||||Wn |jy=YdSw|rCt |rKt | |d|rPt |rUt |r]t || d|rit| dt| d|rqt||d|rvt| r{t| rt| rt|rtt||||t||||t|d S) a Do all of the default monkey patching (calls every other applicable function in this module). :return: A true value if patching all modules wasn't cancelled, a false value if it was. .. versionchanged:: 1.1 Issue a :mod:`warning ` if this function is called multiple times with different arguments. The second and subsequent calls will only add more patches, they can never remove existing patches by setting an argument to ``False``. .. versionchanged:: 1.1 Issue a :mod:`warning ` if this function is called with ``os=False`` and ``signal=True``. This will cause SIGCHLD handlers to not be called. This may be an error in the future. .. versionchanged:: 1.3a2 ``Event`` defaults to True. .. versionchanged:: 1.3b1 Defined the return values. .. versionchanged:: 1.3b1 Add ``**kwargs`` for the benefit of event subscribers. CAUTION: gevent may add and interpret additional arguments in the future, so it is suggested to use prefixes for kwarg values to be interpreted by plugins, for example, `patch_all(mylib_futures=True)`. .. versionchanged:: 1.3.5 Add *queue*, defaulting to True, for Python 3.7. .. versionchanged:: 1.5 Remove the ``httplib`` argument. Previously, setting it raised a ``ValueError``. .. versionchanged:: 1.5a3 Add the ``contextvars`` argument. .. versionchanged:: 1.5 Better handling of patching more than once. NrrdF)rr%)rrr)r%r Tr)rlocalsrr<rjrer'GeventWillPatchAllEventr)rrrrr r rr r rr rr!GeventDidPatchBuiltinModulesEventGeventDidPatchAllEvent)rrrrrrrrrxrrbuiltinsrr contextvarsr+r%rmodules_to_patchrrrerrrrsR(       rcCs i}tjdd}d}d}t\}}}|ry|ddry|ddd}|dkr-|d7}n@|dkr4d }n9|d rJ|d d |vrJd||d d<n#||vrbd ||<||vra|D]}||dqXn t|dd||d=|ry|dds|rddl} ddl} t dd dd| Dt dtj ddft d| tjt d| ttjt d| |st |dS|tjdd<ztj} Wn tyd} Ynwtjttj| <dtjvrtj| tjd_tdi|ddl} t| |} | tjdddS)NrFrun_pathrz--verboser run_modulezno-rrTz zCannot patch %rzgevent.monkey.patch_all(%s), cs|]}d|VqdS)z%s=%sNr)rr?rrr zmain..zsys.version=%s  z sys.path=%szsys.modules=%szcwd=%sz gevent.monkeyrj__main__)run_namer)rxargv_get_script_help startswithreplacerKexitpprintrprintrr<versionstrippformatpathsortedrykeysgetcwd__spec__r; NameErrorrmonkeyrrunpyr:)r*r3r)run_fn script_helppatch_all_argsryoptionrr8rr2rDrun_methrrrrs\       rcCshddl}z|j}Wn ty|j}Ynw|td}dd|D}dddd|D}|||fS)NrcSsg|] }d|tvr|qS)patch_)globals)rxrrrr2sz$_get_script_help..agevent.monkey - monkey patch the standard modules to use gevent. USAGE: ``python -m gevent.monkey [MONKEY OPTIONS] [--module] (script|module) [SCRIPT OPTIONS]`` If no MONKEY OPTIONS are present, monkey patches all the modules as if by calling ``patch_all()``. You can exclude a module with --no-, e.g. --no-thread. You can specify a module to patch with --, e.g. --socket. In the latter case only the modules specified on the command line will be patched. The default behavior is to execute the script passed as argument. If you wish to run a module instead, pass the `--module` argument before the module name. .. versionchanged:: 1.3b1 The *script* argument can now be any argument that can be passed to `runpy.run_path`, just like the interpreter itself does, for example a package directory containing ``__main__.py``. Previously it had to be the path to a .py source file. .. versionchanged:: 1.5 The `--module` option has been added. MONKEY OPTIONS: ``--verbose %s``r+csr,)z --[no-]%sNr)rmrrrr-Hr.z#_get_script_help..)inspectgetfullargspecr getargspecrr)rNgetterrGryrFrrrr4*s     r4r1r4)NNNTTT)TTT)TTTTTN)TT)r)NT)T)TTTTTTTTFTTTTTT)7r! __future__rrrxrplatformr5WINrrRuntimeWarningr"r'r0r1rrr6r@rrrJrPrRr]r^rrvr~rSrrrrrrrrrr rrr r rr rr rrrrr4rrrrrs y     # L '      ;     2       aD !