iJ<0SrSSKrSSKrSSKJr SSKJr SSKJr \ "\S\R5r S\ 4Sjr \R\R-4S \4S jjrS \S \4S jr\R$(dS r\rSrSrSrSrSrO\R4(dSrSrSrSrSrSr\"S5rSrO\S r\r\R8(aSrOSrSr\R8(aSrOSrSr\R:(a \"S5rSrO \"S5rSr\"S\-S -\-S!-\-S"-\-S#-\-S$-\-S%-\-S&-\-S'-5r\"S(\-S)-\-S*-5rS+\4S,jr S-\S.\S/\ 4S0jr!S-\S.\S/\"4S1jr#S.\S/\"4S2jr$S8S3\%S.\S/\&4S4jjr'S.\S/\&4S5jr(S6\ 4S7jr)g)9aX Tools for searching bytecode for key statements that indicate the need for additional resources, such as data files and package metadata. By *bytecode* I mean the ``code`` object given by ``compile()``, accessible from the ``__code__`` attribute of any non-builtin function or, in PyInstallerLand, the ``PyiModuleGraph.node("some.module").code`` attribute. The best guide for bytecode format I have found is the disassembler reference: https://docs.python.org/3/library/dis.html This parser implementation aims to combine the flexibility and speed of regex with the clarity of the output of ``dis.dis(code)``. It has not achieved the 2nd, but C'est la vie... The biggest clarity killer here is the ``EXTENDED_ARG`` opcode which can appear almost anywhere and therefore needs to be tiptoed around at every step. If this code needs to expand significantly, I would recommend an upgrade to a regex-based grammar parsing library such as Reparse. This way, little steps like unpacking ``EXTENDED_ARGS`` can be defined once then simply referenced forming a nice hierarchy rather than copied everywhere its needed. N)CodeType)Pattern)compat _all_opmapxcP[R"[[U/55$)z? Get a regex-escaped opcode byte from its human readable name. )reescapebytesopmap)rs HC:\des-py\RoboSAPF\venv\Lib\site-packages\PyInstaller\depend\bytecode.py_instruction_to_regexr)s 99UE!H:& ''patternc[U[5(de[R"SSU5n[R"XS9$)a A regex-powered Python bytecode matcher. ``bytecode_regex`` provides a very thin wrapper around :func:`re.compile`. * Any opcode names wrapped in backticks are substituted for their corresponding opcode bytes. * Patterns are compiled in VERBOSE mode by default so that whitespace and comments may be used. This aims to mirror the output of :func:`dis.dis`, which is far more readable than looking at raw byte strings. s`(\w+)`c:[USR55$)N)rdecode)ms r  bytecode_regex..@s'! 6r)flags) isinstancer r subcompile)rrs r bytecode_regexr0sA gu % %% %ff6G ::g ++rstringc## [U[5(de[U5nURU5nUHBnUR 5S-S:XaUv M URXR 5S-5n O gMK7f)a Call ``pattern.finditer(string)``, but remove any matches beginning on an odd byte (i.e., matches where match.start() is not a multiple of 2). This should be used to avoid false positive matches where a bytecode pair's argument is mistaken for an opcode. rrN)rr _cleanup_bytecode_stringfinditerstart)rrmatchesmatchs r r!r!Fs fe $ $$ $ %f -Fv&G E{{}q A% "**6;;=13DE  sBBs`EXTENDED_ARG`s%`LOAD_NAME`|`LOAD_GLOBAL`|`LOAD_FAST`s`LOAD_ATTR`|`LOAD_METHOD`s `LOAD_CONST`s0`CALL_FUNCTION`|`CALL_METHOD`|`CALL_FUNCTION_EX`cU$Nbytecodes r r r psrs#`EXTENDED_ARG`|`EXTENDED_ARG_QUICK`s"`EXTENDED_ARG``EXTENDED_ARG_QUICK`s`PRECALL`|`CALL_FUNCTION_EX`s(`CACHE`.)|(..)c.[RSU5$Ns\2_cache_instruction_filterrr(s r r r s(,,VX>>rs8`LOAD_NAME`|`LOAD_GLOBAL`|`LOAD_FAST`|`LOAD_FAST_BORROW`s `LOAD_ATTR`s3`LOAD_CONST`|`LOAD_SMALL_INT`|`LOAD_CONST_IMMORTAL`s`CALL`|`CALL_FUNCTION_EX`s(`CACHE`.)|(`PUSH_NULL`.)|(..)c.[RSU5$)Ns\3r,r(s r r r ,00B Brc.[RSU5$r+r,r(s r r r r/rs # Matches `global_function('some', 'constant', 'arguments')`. # Load the global function. In code with >256 of names, this may require extended name references. ( (?:(?:s).)* (?:(?:s).) ) # For foo.bar.whizz(), the above is the 'foo', below is the 'bar.whizz' (one opcode per name component, each # possibly preceded by name reference extension). ( (?: (?:(?:s).)* (?:s). )* ) # Load however many arguments it takes. These (for now) must all be constants. # Again, code with >256 constants may need extended enumeration. ( (?: (?:(?:s).)* (?:s). )* ) # Call the function. If opcode is CALL_FUNCTION_EX, the parameter are flags. For other opcodes, the parameter # is the argument count (which may be > 256). ( (?:(?:s).)* (?:s ). ) s:( # Arbitrary number of EXTENDED_ARG pairs. (?:(?:sG).)* # Followed by some other instruction (usually a LOAD). [^s]. ) extended_argsc:[RUSSS2S5$)a9 Unpack the (extended) integer used to reference names or constants. The input should be a bytecode snippet of the following form:: EXTENDED_ARG ? # Repeated 0-4 times. LOAD_xxx ? # Any of LOAD_NAME/LOAD_CONST/LOAD_METHOD/... Each ? byte combined together gives the number we want. rNrbig)int from_bytes)r1s r extended_argumentsr6s  >>-1-u 55rrawcodereturnc[U5nUS[S:XaURU$US[S:XaURU$[R (a"US[S:XaUR US- $[R(a"US[S:XaUR US- $[R(aUS[S:XaU$[R(aUS[S:XaURU$[R(aUS[S :XaURU$UR U$) z+ Parse an (extended) LOAD_xxx instruction. LOAD_FAST LOAD_CONST LOAD_GLOBALr LOAD_ATTRLOAD_SMALL_INTLOAD_CONST_IMMORTALLOAD_FAST_BORROW) r6r co_varnames co_constsris_py311co_namesis_py312is_py314)r7r8indexs r loadrJs& s #E  2w% $$&& 2w% %%~~e$$ 3r7eM&::}}UaZ(( 3r7eK&88}}UaZ(( 3r7e,<&==  3r7e,A&BB~~e$$ 3r7e,>&??&& == rcj[RU5Vs/sHn[X!5PM sn$s snf)z Parse multiple consecutive LOAD_xxx instructions. Or load() in a for loop. May be used to unpack a function's parameters or nested attributes ``(foo.bar.pop.whack)``. )_extended_arg_bytecodefindallrJ)r7r8is r loadsrOs- $:#A#A##F G#FaDM#F GG Gs0c/n[[UR5HnUR5up4pV[ X05n[ X@5nSR U/U-5n[ XP5nUS[S:XaK[U5nUS:waMo[U5S:wd[US[5(dM[US5nO[U5n U [U5:waMURXu45 M U$)zB Scan a code object for all function calls on constant arguments. .rCALL_FUNCTION_EXr)r!_call_function_bytecodeco_codegroupsrJrOjoinr r6lenrtuplelistappend) r8outr$ function_rootmethodsargs function_callfunctionr arg_counts r function_callsrbs C14<<@6;lln3  ]1 &88]Og56T   u%78 8&}5Ez4yA~ZQ%?%?Q=D*=9ICI% H#$;A> JrsearchcUc0nX;a@U"U5X!'URH&n[U[5(dM[XU5 M( U$)ze Apply a search function to a code object, recursing into child code objects (function definitions). )rDrrsearch_recursively)rcr8_memoconsts r rereBsK } Tl ^^E%**"6%8$ Lrc"[[U5$)z Scan a code object for function calls on constant arguments, recursing into function definitions and bodies of comprehension loops. )rerb)r8s r recursive_function_callsriPs nd 33r full_namec## URS5nU(a"SRU5v USSnU(aM!gg7f)aList possible aliases of a fully qualified Python name. >>> list(any_alias("foo.bar.wizz")) ['foo.bar.wizz', 'bar.wizz', 'wizz'] This crudely allows us to capture uses of wizz() under any of :: import foo foo.bar.wizz() :: from foo import bar bar.wizz() :: from foo.bar import wizz wizz() However, it will fail for any form of aliases and quite likely find false matches. rQrN)splitrV)rjpartss r any_aliasrnXs8& OOC E hhuoab  %s8>>r&)*__doc__disr typesrtypingr PyInstallerrgetattrr strrVERBOSEDOTALLr rr!rE_OPCODES_EXTENDED_ARG_OPCODES_EXTENDED_ARG2_OPCODES_FUNCTION_GLOBAL_OPCODES_FUNCTION_LOAD_OPCODES_FUNCTION_ARGS_OPCODES_FUNCTION_CALLr rGr-rHis_py313rSrLr6rJrYrOrbcallabledictrerirnr'rr rs"  \399-(S(*,bii)?,E,,guB.2H:-Q  DCH:-= !//B C? /2 #_ #L , "Y!1:$23U$V! C%33F$G! C ) ' ' *  * * - ) ),''*,*-*,--.(/(.+/<(=(<+ = >&?&>)?!#L(%&)  # # &  6e 6$ e$ 8$ $ NHuHHHH&&d&R x x  4844r