o ڭjE5@sUdZddlmZddlZddlZddlZddlZddlZddlZddlm Z ddlm Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd l mZddlZ ddl mZerjddlmZedZedZejjZdmddZGdddejZej Z!de"d<ej#dkrddl$Z%e%j&Z'nddl'Z'dnd d!Z(dod$d%Z)dod&d'Z*dod(d)Z+dpdqd,d-Z,drd/d0Z-d1d2dd3dsd:d;Z.dtdd?e0d@DZ1e12e3dAdBe3dCdDe3dEdFidudHdIZ4e5e6fZ7dvdLdMZ8dwdOdPZ9ej:GdQdRdRZ;dSdTZdxd[d\Z?dyd^d_Z@er.ej#dkr'dd`l mAZAndd`lmAZAnej#dkr;dd`l mAZAndadbZAej#dkrLddclmBZBn GdddedeeeefZBdzdgdhZCd{dkdlZDdS)|z"Python version compatibility code.) annotationsN) Parameter) signature)Path)Any)Callable)Generic)NoReturn) TYPE_CHECKING)TypeVarT)overload)Final_T_Spathstr | os.PathLike[str]return LEGACY_PATHcCst|S)zBInternal wrapper to prepare lazy proxies for legacy_path instances)r)rrK/var/www/html/CropPilot/venv/lib/python3.10/site-packages/_pytest/compat.py legacy_path0src@seZdZdZdS) NotSetTyperN)__name__ __module__ __qualname__tokenrrrrr8srr NOTSET)funcCallable[..., Any]strcCs tt|SN)r!rrrrr _format_argsE r$objectboolcCst|}|o t| Sr")inspectisgeneratorfunctioniscoroutinefunction)rgenfuncrrr is_generatorIs r,cCst|p t|ddS)a{Return True if func is a coroutine function (a function defined with async def syntax, and doesn't contain yield), or a function decorated with @asyncio.coroutine. Note: copied and modified from Python 3.5's builtin couroutines.py to avoid importing asyncio directly, which in turns also initializes the "logging" module as a side-effect (see issue #8). _is_coroutineF)r(r*getattrr#rrrr*Ns r*cCst|pt|S)zZReturn True if the given function seems to be an async function or an async generator.)r*r(isasyncgenfunctionr#rrris_async_functionZsr0curdir str | NonecCsht|}tt|}|jj}|dur,z||}Wn ty#Yn wd||dfSd||dfS)Nz%s:%d) get_real_funcrr(getfile__code__co_firstlineno relative_to ValueError)functionr1fnlinenorelfnrrr getlocation`s r>intcsXt|dd}|s dSttjddtttjddttfdd|DS) z>Return number of arguments used up by mock arguments (if any). patchingsNrmockDEFAULTz unittest.mockcs*g|]}|js|jus|jur|qSr)attribute_namenew.0p mock_sentinelut_mock_sentinelrr xsz'num_mock_patch_args..)r.sysmodulesgetr&len)r:r@rrHrnum_mock_patch_argsns  rPF)name is_methodclsr:rRrSrT type | Nonetuple[str, ...]c Cszt|j}Wn&ttfy-}zddlm}|d|d|ddWYd}~nd}~wwtdd |D}|s>|j}|sM|rSt t j ||dd t sS|d d}t |d r`|t|d}|S) aLReturn the names of a function's mandatory arguments. Should return the names of all function arguments that: * Aren't bound to an instance or type as in instance or class methods. * Don't have default values. * Aren't bound with functools.partial. * Aren't replaced with mocks. The is_method and cls arguments indicate that the function should be treated as a bound method even though it's not unless, only in the case of cls, the function is a static method. The name parameter should be the original name in which the function was collected. r)failz!Could not determine arguments of z: F)pytraceNcss:|]}|jtjus|jtjur|jtjur|jVqdSr"kindrPOSITIONAL_OR_KEYWORD KEYWORD_ONLYdefaultemptyrRrErrr s   z"getfuncargnames..)r]r3 __wrapped__)r parametersr9 TypeError_pytest.outcomesrWtuplevaluesr isinstancer(getattr_static staticmethodhasattrrP)r:rRrSrTraerW arg_namesrrrgetfuncargnamess4    rlcCstddt|jDS)Ncss4|]}|jtjtjfvr|jtjur|jVqdSr"rYrErrrr_s z(get_default_arg_names..)rdrrare)r:rrrget_default_arg_namess rmcCs(i|]}|tddvr|d|dqS) z\x02x)range)rFirrr s"rs z\t z\r z\nscCs |tSr") translate$_non_printable_ascii_translate_table)rxrrr_translate_non_printables r{valbytescCs |ddS)Nasciibackslashreplace)decode)r|rrr_bytes_to_asciir%r bytes | strcCs2t|tr t|}t|S|dd}t|S)aIf val is pure ASCII, return it as an str, otherwise, escape bytes objects into a sequence of escaped bytes: b'\xc3\xb4\xc5\xd6' -> r'\xc3\xb4\xc5\xd6' and escapes unicode objects into a sequence of escaped unicode ids, e.g.: r'4\nV\U00043efa\x0eMXWB\x1e\u3028\u15fd\xcd\U0007d944' Note: The obvious "v.decode('unicode-escape')" will return valid UTF-8 unicode if it finds them in bytes, but we want to return escaped bytes for any byte, even if they match a UTF-8 string. unicode_escaper~)rfr}rencoderr{)r|retrrr ascii_escapeds rc@seZdZUdZded<dS)_PytestWrappera%Dummy wrapper around a function object for internal use only. Used to correctly unwrap the underlying function object when we are creating fixtures, because we wrap the function object ourselves with a decorator to issue warnings when the fixture function is called directly. robjN)rrr__doc____annotations__rrrrrs  rcCs|}tdD] }t|dd}t|tr|j}n"t|dd}|dur$n|}qddlm}tdj||||dt|t j rC|j }|S) zjGet the real function object of the (possibly) wrapped object by functools.wraps or functools.partial.d__pytest_wrapped__Nr`r)safereprzrPrlrmrqrzupdateordr{r}r! STRING_TYPESrr dataclassrr4rrrrrrrrrrrrs                    F           4