a !fE5@s.UdZddlmZddlZddlZddlZddlZddlZddlZddlm Z ddlm Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd l mZddlZdd l mZerddlmZedZedZejjZdddddZGdddejZej Z!de"d<ej#dkr6ddl$Z%e%j&Z'nddl'Z'dddddZ(d d!dd"d#Z)d d!dd$d%Z*d d!dd&d'Z+djd(dd)d*d+Z,d,d-d.d/Z-d0d1dd2ddd!d3d4d5d6d7Z.dd4d8d9d:Z/d;d<e0d=DZ1e12e3d>d?e3d@dAe3dBdCidddDdEdFZ4e5e6fZ7dGddHdIdJZ8dKddHdLdMZ9ej:GdNdOdOZ;dPdQZdVddVdVdWdXdYZ?d d!dZd[d\Z@erej#dkrdd]l mAZAn dd]lmAZAn"ej#dkrdd]l mAZAnd^d_ZAej#dkrdd`lmBZBnGdadbdbeeefZBdcd-dddeZCdfdfdgdhdiZDdS)kz"Python version compatibility code.) annotationsN) Parameter) signature)Path)Any)Callable)Generic)NoReturn) TYPE_CHECKING)TypeVar)overload)Final_T_Szstr | os.PathLike[str] LEGACY_PATH)pathreturncCst|S)zBInternal wrapper to prepare lazy proxies for legacy_path instances)r)rrO/var/www/html/python-backend/venv/lib/python3.9/site-packages/_pytest/compat.py legacy_path0src@seZdZdZdS) NotSetTyperN)__name__ __module__ __qualname__tokenrrrrr8srr NOTSET)zCallable[..., Any]strfuncrcCs tt|SN)rrr rrr _format_argsEsr#objectboolcCst|}|ot| Sr!)inspectisgeneratorfunctioniscoroutinefunction)r Zgenfuncrrr is_generatorIs r)cCst|pt|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_functionZsr-z str | None)curdirrcCsht|}tt|}|jj}|durXz||}WntyFYn0d||dfSd||dfS)Nz%s:%d) get_real_funcrr&getfile__code__co_firstlineno relative_to ValueError)functionr.fnlinenoZrelfnrrr getlocation`s r9int)rcsXt|dd}|sdSttjddtttjddttfdd|DS) z>Return number of arguments used up by mock arguments (if any). patchingsNrZmockDEFAULTz unittest.mockcs*g|]"}|js|jus"|jur|qSr)Zattribute_namenew.0pZ mock_sentinelZut_mock_sentinelrr xsz'num_mock_patch_args..)r+sysmodulesgetr$len)r6r;rrArnum_mock_patch_argsns  rGF)name is_methodclsz type | Noneztuple[str, ...])r6rIrJrKrc Cszt|j}WnLttfyZ}z0ddlm}|d|d|ddWYd}~n d}~00tdd |D}|s||j}|s|rt t j ||dd t s|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)ZpytraceNcss8|]0}|jtjus|jtjur|jtjur|jVqdSr!kindrPOSITIONAL_OR_KEYWORD KEYWORD_ONLYdefaultemptyrIr>rrr s    z"getfuncargnames..)rQr/ __wrapped__)r parametersr5 TypeError_pytest.outcomesrLtuplevaluesr isinstancer&getattr_static staticmethodhasattrrG)r6rIrJrKrUerL arg_namesrrrgetfuncargnamess0    r`)r6rcCstddt|jDS)Ncss2|]*}|jtjtjfvr|jtjur|jVqdSr!rMr>rrrrSs z(get_default_arg_names..)rXrrUrY)r6rrrget_default_arg_namess racCs(i|] }|tddvr|d|dqS) z\x02x)range)r?irrr srg z\t z\r z\n)srcCs |tSr!) translate$_non_printable_ascii_translate_table)rlrrr_translate_non_printablesrobytes)valrcCs |ddS)Nasciibackslashreplace)decode)rqrrr_bytes_to_asciisruz bytes | strcCs,t|trt|}n|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_escaperr)rZrpruencodertro)rqretrrr ascii_escapeds  ryc@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__rrrrrzs rzcCs|}tdD]@}t|dd}t|tr0|j}qtt|dd}|durHqt|}q ddlm}tdj||||dt|t j r|j }|S) zjGet the real function object of the (possibly) wrapped object by functools.wraps or functools.partial.dZ__pytest_wrapped__NrTr)safereprzs              F     4