pPjuzdZddlmZddlZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZddlmZddlmZdd lmZmZdd lmZdd lmZmZdd lm Z m!Z!dd l"m#Z#m$Z$ddl%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJddlKmLZLddlMmNZNddlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXddlYmZZZddl[m\Z\m]Z]m^Z^ddl_m`Z`maZaddlbmcZcddldmeZeddlfmgZgddlhmiZiddljmkZkmlZldd lmmnZndd!lompZpdd"lqmrZrdd#lsmtZtdd$lumvZvdd%lwmxZxdd&lymzZzdd'l{m|Z|dd(l}m~Z~dd)lmZeee edzfZeeZeeeefZGd*d+ZGd,d-eZ dD dEd.Z dFd/Z dGd0Z dHd1Z dId2ZdJd3ZdKd4Z dLd5Z dMd6ZdNd7ZdOd8Z dPd9ZdQd:ZdRd;ZdSd<ZGd=d>Ze d?ZdTd@ZdUdAZdVdBZdWdCZy)XzHGenerate C code for a Python C extension module from Python source code.) annotationsN)Iterable)TypeVar) BuildResult BuildSourceStatebuild compute_hashcreate_metastoreget_cache_namessorted_components) CompileError)FileSystemCache)MypyFileTypeInfo)Options)PluginReportConfigContext) hash_digest json_dumps)find_class_dependenciesfind_implicit_op_dependencies)c_string_initializer)EmitterEmitterContextHeaderDeclarationc_array_initializernative_function_doc_initializer)generate_classgenerate_class_reusegenerate_class_type_decl)generate_native_functionnative_function_header) generate_legacy_wrapper_functiongenerate_wrapper_functionlegacy_wrapper_function_headerwrapper_function_header)Literals) EXT_SUFFIXGENERATOR_HELPER_NAMEIS_FREE_THREADED MODULE_PREFIXPREFIXRUNTIME_C_FILESTOP_LEVEL_NAMETYPE_VAR_PREFIXmodule_exec_namemodule_import_state_namemodule_init_namemodule_init_only_namemodule_lock_api_nameshared_lib_nameshort_id_from_name) catch_errors)Errors) LIBRT_BASE64 LIBRT_RANDOM LIBRT_STRINGSLIBRT_THREADING LIBRT_TIME LIBRT_VECSCapsule HeaderDep SourceDep)FuncIR)ModuleIR ModuleIRsdeserialize_modules) DeserMaps LoadLiteral)RType)build_ir)Mapper) load_type_map) NameGenerator exported_name)CompilerOptions)borrow_generator_attrs)do_copy_propagation)insert_exception_handling)do_flag_elimination)insert_event_trace_logging)lower_ir)insert_ref_count_opcodes) insert_spills)insert_uninit_checksceZdZdZddZy)MarkedDeclarationz(Add a mark, useful for topological sort.c ||_d|_y)NF) declarationmark)selfr\r]s ]/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/codegen/emitmodule.py__init__zMarkedDeclaration.__init__s& N)r\rr]boolreturnNone)__name__ __module__ __qualname____doc__r`rar_rZrZ|s 2rarZcLeZdZdZ dfd ZddZddZd dZxZS) MypycPluginaPlugin for making mypyc interoperate properly with mypy incremental mode. Basically the point of this plugin is to force mypy to recheck things based on the demands of mypyc in a couple situations: * Any modules in the same group must be compiled together, so we tell mypy that modules depend on all their groupmates. * If the IR metadata is missing or stale or any of the generated C source files associated missing or stale, then we need to recompile the module so we mark it as stale. ct||i|_|D]/\}}td|D}|D]}||f|j|<1||_t |d|_y)Nc34K|]}|jywN)module).0sources r_ z'MypycPlugin.__init__..sAvV]]AF)parallel_worker)superr` group_mapsortedcompiler_optionsr metastore) r^optionsrxgroupssourcesnamemodulesid __class__s r_r`zMypycPlugin.__init__su !BD# 5MGTAAAG 5&*G_r" 5 5 !1)'5Irac(|j|j|j}}}||jvry|s|j|St |||j \}}}t |||j } |jj|}|jj|} tj| } t|| dk7ry| djD]o\}} ttjj!|j"j$|d5} | j} dddt }| |k7soy|j|S#t$rYywxYw#1swY;xYw#t$rYywxYw)N meta_hash src_hashesrb)rpathis_checkrvr rzget_ir_cache_nameryreadFileNotFoundErrorjsonloadsritemsopenosjoinrx target_dir)r^ctxrrr meta_path_ir_path meta_jsonir_jsonir_datahashfcontents real_hashs r_report_config_datazMypycPlugin.report_config_datas !VVSXXs||(D T^^ #>>"% %*"dDLLA 1a#Bdll; ++I6Inn))'2G**W% y !W[%9 9 ",/557 JD$ "'',,t'<'<'G'GNPTU(YZ vvxH($H-Iy  ~~b!!5!   $(($  s<86E)/>F-E8>F) E54E58F =F FFc|jj|jdgfdDcgc]}d|df c}Scc}w)N )rvgetfullname)r^filers r_get_additional_depszMypycPlugin.get_additional_depss<'+~~'9'9$--$PR'TUV'WXR XXXs =ch|j|jvr tSt}|jj D]h}|j }t |ts |j|jk(s:|jddD]}|j|jj|S)a=Modules defining MRO ancestors of classes defined in this module. The generated C for a class (vtable arrays, getter/setter tables, object struct) references every inherited method/attribute of every ancestor, including ancestors defined in modules this module does not import directly. Recording them as indirect dependencies makes an ancestor's interface change re-trigger type checking (and hence C regeneration) of this module. Only top-level classes are scanned: mypyc rejects nested class definitions. rN) rrvsetnamesvaluesnode isinstancer module_namemroadd)r^rmodssymrancestors r_get_additional_indirect_depsz(MypycPlugin.get_additional_indirect_depss == .5L::$$& 3C88D$)d.>.>$--.O $ 3HHHX1123 3  ra)rzrrxrOr{Groupsrcrd)rrrcz#tuple[str | None, list[str]] | None)rrrczlist[tuple[int, str, int]])rrrcset[str]) rerfrgrhr`rrr __classcell__)rs@r_rkrksC  J J2A JKQ J  J/"bYrarkcf|jsJdt|||} t|||||g}|jj |j r9|j jj t|j |S#|jj wxYw)Nz!strict_optional must be turned on)r|rz alt_lib_pathfscache extra_plugins)strict_optionalrkr rycloseerrorsmanagerr)r|rzrxr{rr mypyc_pluginresults r_parse_and_typecheckrs  " "G$GG "w(8&AL '%'.   $$& }}  &&(6==)) M $$&s BB0cT|jr0tdjdjd|Dt ||j |j |||}|jdkDr|Si}|jD]/}|jD]}|js|||j< 1|jD]Q}|j |jj} |jD]} t| | j5t!| |j"t%| |j"| |vrt'| || t)| | |vrt+| || |j,r t/| |t1| |t3| } | |j4j7| t9| |t;| |ddd|jD]+} t=| } | |j4j7| -T|S#1swY.xYw)aCompile an SCC into ModuleIRs. Any modules that this SCC depends on must have either been compiled, type checked, or loaded from a cache into mapper. Arguments: scc: The list of MypyFiles to compile result: The BuildResult from the mypy front-end mapper: The Mapper object mapping mypy ASTs to class and func IRs compiler_options: The compilation options errors: Where to report any errors encountered Returns the IR of the modules. z Compiling {}, c34K|]}|jywrn)r})rpxs r_rrz$compile_scc_to_ir..s-Baff-BrsrN)verboseprintformatrrJgraphtypes num_errorsrclassesenv_user_functionrxpath functionsr8linerXstrict_traceback_checksrRrPrVrW log_tracerTrUr dependenciesupdaterQrSr) sccrmapperrxrr~generator_spill_ownersrocls module_pathfndepscls r_compile_scc_to_irrs, n##DII-Bc-B$BCDsFLL&,,@PRXYG 1.."D>> DC$$@C&s'<'<= DD .."!1ll6??399 "" :Bk2773 :$R)9)Q)QR)".>.V.VW//*2/Eb/IJ(,//!"&.as U2Bfnn>>>Us"%)rGr rrwmod_idsrrvtreeallload_scc_from_cacherrrr setdefaultrrdecl)rrrxr deser_ctxr~rr scc_statessttreesfreshscc_ir module_irrrs` r_compile_modules_to_irrMs_"b!IG!.C17 1DE2fll2&E E#-WR&:J:J1JrwwWW UUU  vvy A&uff>NPVWF NN6 "$]]_ C #++BB%%00bAB#--CB''22277::rBC C!C, N+FWsE;F: FFc P|Dcic]:\}}|D]0}|j|j|jj2<}}}}t|Dcgc]\}}|Dcgc]}|jc}!c}}}|j} i} |D]y\} } | Dcic]*}|j|vr|j||j,} }| st | || | <Mt | || |j| |}|j| | <{| Scc}}}wcc}wcc}}}wcc}w)zCompile a collection of ModuleIRs to C source text. Returns a dictionary mapping group names to a list of (file name, file text) pairs. )separate) rorrrMr_load_cached_group_filesGroupGeneratorrvgenerate_c_for_modules)r{r~rrrxr|rrq source_pathsrctext group_sources group_name group_modules generators r_compile_ir_to_crssT! GQ   v||FMM2888L AGHH:7Ag .F&-- .H!** E68E%+?! z( }}' MM76==1 1   !9 OE*  " <V5E5EuN^ &<<>j#?& LC /H s#?D D !D4D /D#D c|D]}|jj|j}|+ |jjj t |} tj|}|jdiDcgc]}|dfc}cSgS#ttf$rYwxYw#tj$rYwxYwcc}w)a&Read the .c/.h paths recorded for this group on the previous run. All modules in a group share the same src_hashes map, so the first readable IR cache is sufficient. Returns paths paired with empty content so callers can distinguish "reuse on disk" from "newly generated". r) rrrorryrget_state_ir_cache_namerOSErrorrrJSONDecodeError)rrrqstaterrrs r_rrs F   / =  nn..334KE4RSG jj)G(/{{<'DEtr EE F I"7+   ##   Es).BB/ CB,+B,/CCcht|||\}}}|jddjddS)Nz .meta.jsonz.ir.jsonz.meta.ff)r replace)rrrzrrs r_rrs6%b$8OIq!   \: 6 > >z: VVracXt|j|j|jSrn)rrrrz)rs r_rrs UXXu{{EMM BBrac i}|jD]'\}}|Dcic]\}}|t|c}}||<)|jD]\} } |j| } t| | j|j j \} } } |j jj| }t| }| jt|||| d}|j jj|t||j jjycc}}w#t$rYwxYw)aWrite out the cache information for modules. Each module has the following cache information written (which is in addition to the cache information written by mypy itself): * A serialized version of its mypyc IR, minus the bodies of functions. This allows code that depends on it to use these serialized data structures when compiling against it instead of needing to recompile it. (Compiling against a module requires access to both its mypy and mypyc data structures.) * The hash of the mypy metadata cache file for the module. This is used to ensure that the mypyc cache and the mypy cache are in sync and refer to the same version of the code. This is particularly important if mypyc crashes/errors/is stopped after mypy has written its cache but before mypyc has. * The hashes of all the source file outputs for the group the module is in. This is so that the module will be recompiled if the source outputs are missing. )irrrN)rr rr rrrzryrrr serializerwritercommit)r~rrvrhashesr}filesrdatarrorrr meta_datanewpathrs r_ write_cacher s84F{{}J eCHIZT4l400It JmmoE F \\" )"bhh8N8NO 1a 0055i@I*"-""$$Y/ 2/    &&w 70CD#E& NN##%-J   sD;%E E  E c (|Dcic]h}|jtj|jjj t |j|jdj}}t||}t||||Scc}w)zfLoad IR for an SCC of modules from the cache. Arguments and return are as compile_scc_to_ir. r) rrrrryrrrrFrL)rrrrk cache_datar~s r_rrs   DJJ NN $ $ ) )*A&,,qzzBZ*[ \  J "*c2G&#s# NsA-Bc$t}|jD]r}|jD]a}t|tr|j s |j |2t|tsC|j |jct|S)z4Collect all SourceDep dependencies from all modules.) rrrrrBinternalrr@ internal_dep)r~ source_depsrodeps r_collect_source_dependenciesrsx"%%K.."4&& 4C#y)<<OOC(C) 0 0 23  44 ractt}|jD]}|jD]}t|tt fr0|j |k(s)|j|jI|r|jn|j}|j|j|S)z1Collect all header dependencies from all modules.) rrrrrBrArr get_headerr external_dep)r~r header_depsror capsule_deps r_collect_header_dependenciesrsEK..":&& :C# 956<<8+OOCNN$454N)roscoperzr) rorKrrset_filerzrrrr ) rrxrr{grouplib_namerqrvrr~rrr}s r_compile_modules_to_cr!)s*AG[[_UHUZ[6([[I[ I F NN""$dFNN4J4J#$FF4DfMG 12vbz!! FGVV=M NEE2 7WQU4[7 ??!\ 8s C?Cctt|j|dd|jj|j |j<|j tk7r|jst||jr\tt||jdd|jjt|j|jz<ytt||jdd|jjt|j|jz<yyyN;T needs_export)rr#rcontext declarationsnative_function_namer}r/ris_fastcall_supported capi_versionr'rr-cnamer&)remitters r_generate_function_declarationr.QsJ[ !"''7 3 4A6TKGOO  !=!=bgg!FG ww.  !W%9%9 :M^*2w}}=>a@tNGOO ( ("((7==2I)I JN_1"gmmDEQGVZNGOO ( ("((7==2I)I J*5 rac`d|vr|j|d|dS|j|d|S)zHGiven a C decl and its name, modify it to be a declaration to a pointer.(z(*)*)r)rr}s r_ pointerizer3cs= d{||DBtfA,//||DAdV*--racdtjj|jdddS)z>Given a group name, return the relative directory path for it..Nr)rseprsplit)rs r_ group_dirr8ns' 66;;z'',Sb1 22raceZdZ ddZed dZed dZd!dZd"dZd#dZ d$dZ d$dZ d%d Z d&d Z d'd Z d(d Zd)d Z d'dZd(dZ d(dZd*dZd+dZdd d,dZd-dZd.dZd-dZd"dZd/dZ d0dZd1dZd2dZd3dZy)4rc||_||_t||j|||_||_g|_||_|du|_||_ |j|_ t|_ y)aGenerator for C source for a compilation group. The code for a compilation group contains an internal and an external .h file, and then one .c if not in multi_file mode or one .c file per module if in multi_file mode. Arguments: modules: (name, ir) pairs for each module in the group source_paths: Map from module names to source file paths group_name: The name of the group (or None if this is single-module compilation) group_map: A map of modules to their group names names: The name generator for the compilation compiler_options: Mypyc specific options, including multi_file mode N) r~rrrr'r simple_initsruse_shared_librx multi_filer+multi_phase_init)r^r~rrrvrrxs r_r`zGroupGenerator.__init__tsu. (% #;;Z   46$(4 0*55!1racN|jrdt|jzSdS)Nrr)rrNr^s r_ group_suffixzGroupGenerator.group_suffixs!7;s]4??33NBNracr|jr*dt|jjddzSdS)Nrr5rr)rrNr7r@s r_short_group_suffixz!GroupGenerator.short_group_suffixs2FJoos]4??#8#8#=b#ABB][]]rac g}jxr j}jjD]3}|jD]"}t |j j$5tj }jjrtD]}|jd|dtj}t|dD]!}|jd|jd#jj r|jd|jdj"d|jdj"d|} jrj%j'jj)D]Y\} }|rbtj j*|  } | jdj"d| jdj"dj-| | j/| | j1|j2| |j4D]} | j6st9| | | |j4D cic]} | j:s| j<| } } j?| | ||jD]}| jd} |j@j<tBk(r'|jD| jG|jD} tI|| j*| | | |j<tJk7s|jLr| jtO|| jPrtS|| j*| | tU|| j*| | |sd tW| d }|jY|d j[| j\f\tj }|jd j^d|jdj^d|jd|jdd%fd }||dtj }|jdj^d|jdj^d|jd|jdjjs ||d|jdj"d|j|jd|jjj)D]\} }ja| |jb||j4D]+} te| | ||| jfsti| | ||-jk| |jl||jD]}to||tj jpD]}}tW|}tW|jsdd}|judjwtxjj[t{|d |dd|d|dj}}|} j| | j|D]}|jr|n|}|jsp|jtd|j@d g|j@d!d|jr| jt|ju| jt|j@|jt|j@jr9jjrj|| j| |jd"|jd"jrt{jnd }|txjj[|d#j"d d j[| j\ftxjj[|d$j"dd j[|j\ftxjj[|d#j"dd j[|j\fgzScc} w)&Nz #include <>c|jSrn)r)ds r_z7GroupGenerator.generate_c_for_modules..s ra)keyz(#include z#include "__native.h"z#include "__native_internal)filepath __native_z.crz#ifndef MYPYC_NATIVE_Hz#define MYPYC_NATIVEz#include z#include c|rdnd}jjr|jd|dtj|}t |D]}|jd|dy)N_apirz!#include "internal/librt_internalrJ)rz #include "")rxdepends_on_librt_internal emit_linerr~rw)declsrsuffixr header_depr^s r_emit_dep_headersz?GroupGenerator.generate_c_for_modules..emit_dep_headerssj'VRF$$>>"CF83 OP5dllXVK$[1 < *ZL :; z.hzstruct export_table_z exports_r$zextern rrz#endif__native__native_internal)rSrrrbrcrd)Fr<r=r~rrcollect_literalsr'literalsrrxinclude_runtime_filesr.rRrrwrrQrCdeclare_module_lock_apigenerate_literal_tablesrrdeclare_moduledeclare_internal_globalsdeclare_importsimportsr is_ext_classrhas_running_flagr}generate_module_defrr* class_namerr"r/rr*r+r%r$rNappendr fragmentsrAdeclare_finals final_namesr!reuse_freed_instancer declare_type_varstype_var_namesr. group_depsr7 emit_linesrrr8toposort_declarationsgenerate_globals_initis_typedefnrrgenerate_export_tablegenerate_shared_lib_init)r^ file_contentsr=ror base_emitterr}r source_depr-rrrunning_flag_classesrunning_flag_classext_declarationsrVr(libelib short_lib sorted_declsr\rS output_dirs` r_rz%GroupGenerator.generate_c_for_moduless? ((>&&'QR!3D4K4K3LCPQ!bA$$dBGGG4E4E,F%GHO' IZ#4<<0""%9$:K:K9LB#OP""%9$:K:K9LB#OP""#89""#56 < )51t||, !=d>O>O=PPRST!=d>O>O=PPRST4512$$:: \4 0!3D4K4K3LCPQ :; #'<<#5#5#7 @ K    V-?-? Nnn V(W6F U**(W6F U V  " ";0E0E| T&& @-b,? @ @$,,112 C %D%ciinR&89I  # #&&rww||IcNiPY{Z\D]'^_&tfIdV1=  113  ""7+' 4K(3(;(;$E&&   7;+;+;A+>*?!@X;CSCSTUTVCWX##&G&& (8(89&G&& (8(89   +"2"23 4 ??$$--**+;WE  ) )' 2""8,x(37??Yt/  Z8D4K4K3LB)OP))*   Z+N[rac|jj}|jdd|jd|j D]F\}}|j s|j tdj|j|H|j d|jdd|jd|j D]'\}}|j s|j d|d )|j dy ) aGenerate the declaration and definition of the group's export struct. To avoid needing to deal with deeply platform specific issues involving dynamic library linking (and some possibly insurmountable issues involving cyclic dependencies), compiled code accesses functions and data in other compilation groups via an explicit "export struct". Each group declares a struct type that contains a pointer to every function and static variable it exports. It then populates this struct and stores a pointer to it in a capsule stored as an attribute named 'exports' on the group's shared library's python module. On load, a group's init function will import all of its dependencies' exports tables using the capsule mechanism and copy the contents into a local copy of the table (to eliminate the need for a pointer indirection when accessing it). Then, all calls to functions in another group and accesses to statics from another group are done indirectly via the export table. For example, a group containing a module b, where b contains a class B and a function bar, would declare an export table like: struct export_table_b { PyTypeObject **CPyType_B; PyObject *(*CPyDef_B)(CPyTagged cpy_r_x); CPyTagged (*CPyDef_B___foo)(PyObject *cpy_r_self, CPyTagged cpy_r_y); tuple_T2OI (*CPyDef_bar)(PyObject *cpy_r_x); char (*CPyDef___top_level__)(void); }; that would be initialized with: static struct export_table_b exports = { &CPyType_B, &CPyDef_B, &CPyDef_B___foo, &CPyDef_bar, &CPyDef___top_level__, }; To call `b.foo`, then, a function in another group would do `exports_b.CPyDef_bar(...)`. rzstruct export_tablez { };zstatic struct export_tablez exports = {&,N) r'r(rnrArr&rRr3rr)r^ decl_emitter code_emitterrSr}rs r_rsz$GroupGenerator.generate_export_tablepsX$$11&9$:K:K9LC$PQ++- OJD$  &&z$))DII2F'MN O t$&@ARAR@SS`$ab++- 4JD$  &&4&{3 4 t$rac|jJ|jt|jjdd}|j d|ddddd d t |j}|j d |d |d d |ddddd |j jro|j djt|jddddddddd d|ddj|t|jddddddddd |jD]}t|}|jr#t|}d}|jd|dn"t|}d }|jd!|d|j d"j|t|j||dddd#||d$ddddd |j d%d&d'd|j jr|j d d(|d)dd*d+|jjr|j d,d-d.d/dd d0t!|jjD]l}t|} |j d1jt|d2d3d4d5d6j| t|7d8d9| d:d;j| < n|j d=d%d|jr|j d>|d?d@|dAdBdCdDdE|jrdFnd} |j dG|dHdIdJt|jdKdLdM| dNdO|jr|jdP|dN|jdE|jr|j dQ|dRdS|dTdy|j dQ|dRdUdVdWdXddY|dTdZd[dd\|d]d^d_d[ddXdy)`aGenerate the init function for a shared library. A shared library contains all the actual code for a compilation group. The init function is responsible for creating Capsules that wrap pointers to the initialization function of all the real init functions for modules in this shared library as well as the export table containing all the exported functions and values from all the modules. These capsules are stored in attributes of the shared library. Nr5rzstatic int exec_(PyObject *module){zint res;zPyObject *capsule;zPyObject *tmp;rif (z == NULL) {z = CPyModuleLockAPI_Alloc();z == NULL) goto fail;}z$if (intern_strings() < 0) goto fail;z$if (CPyGlobalsInit() < 0) goto fail;z6capsule = PyCapsule_New(&exports, "{}.exports", NULL);zif (!capsule) {z goto fail;z9res = PyObject_SetAttrString(module, "exports", capsule);zPy_DECREF(capsule);zif (res < 0) {zextern int ensure_deps_z(void);zMcapsule = PyCapsule_New((void *)ensure_deps_{sh}, "{lib}.ensure_deps", NULL);)shr{z=res = PyObject_SetAttrString(module, "ensure_deps", capsule);exec_z extern int z (PyObject *);init_zextern PyObject *z5capsule = PyCapsule_New((void *){}, "{}.{}{}", NULL);z&res = PyObject_SetAttrString(module, "z ", capsule); return 0;fail: return -1;zint ensure_deps_(void)zstatic int done = 0;zif (done) return 0;z(static PyObject *_mypyc_fromlist = NULL;zif (!_mypyc_fromlist) {z,_mypyc_fromlist = Py_BuildValue("(s)", "*");z if (!_mypyc_fromlist) return -1;zPyObject *caps;zGtmp = PyImport_ImportModuleLevel("{}", NULL, NULL, _mypyc_fromlist, 0);zif (!tmp) return -1;z.caps = PyObject_GetAttrString(tmp, "exports");zPy_DECREF(tmp);zif (!caps) return -1;zostruct export_table_{g} *pexports_{g} = (struct export_table_{g} *)PyCapsule_GetPointer(caps, "{lib}.exports");)gr{zPy_DECREF(caps);zif (!pexports_z ) return -1;z8memcpy(&exports_{g}, pexports_{g}, sizeof(exports_{g}));)rz done = 1;zstatic PyModuleDef_Slot slots_[] = {z{Py_mod_exec, exec_},K{Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},"{Py_mod_gil, Py_MOD_GIL_NOT_USED}, {0, NULL},rrzstatic PyModuleDef module_def_z = {PyModuleDef_HEAD_INIT,z .m_name = "",z.m_doc = NULL,z .m_size = rz.m_methods = NULL,z.m_slots = slots_PyMODINIT_FUNC PyInit_z(void) {z$return PyModuleDef_Init(&module_def_);zstatic PyObject *module = NULL;z if (module) {zPy_INCREF(module);zreturn module;z%module = PyModule_Create(&module_def_zif (!module) { return NULL;z if (exec_z(module) < 0) {zPy_DECREF(module);zmodule = NULL;)rrRr6r7rnr5rxrrr~rNr>r1r3r'rmrw) r^r- short_namelock_apimodr}capsule_func_namecapsule_name_prefixregroupsizes r_rtz'GroupGenerator.generate_shared_lib_inits***$T__5;;C@D zl*< =      (88*L )j4 58*0 1  2 2    ) )   HOO#DOO4"K% **W=_ff!t'Gg"O% 7 <<< C %D$$$4S$9!&-#!!K0A/B-"PQ$4S$9!&-#!!$56G5H"PQ   GNN%t'GI\^b"89L8MdVS_`%   : ;sC  ) )   ":,f5&%  ||&&"">-B6$%  7 78 &u- ""]dd'.+D%+^^d^d oe&<_e_'$VHL9NUUX^U_  ,   {K =    0 GD&zl#6]4  ))qr,ZL > $/$//:;2 > a       1*Q? @$    ( I>6zl"E    ( I>1$ 7 |2F J<'78$  # rac|jdddddd|jd|jD]\}}|j|d|dd }|jd |d d d |jddd y)Nrzint CPyGlobalsInit(void)rzstatic int is_initialized = 0;zif (is_initialized) return 0;z CPy_Init(); = r$zbCPyLit_Str, CPyLit_Bytes, CPyLit_Int, CPyLit_Float, CPyLit_Complex, CPyLit_Tuple, CPyLit_FrozenSetz&if (CPyStatics_Initialize(CPyStatics, z) < 0) {rrzis_initialized = 1;r)rnrRr;)r^r-symbolfixuprs r_rpz$GroupGenerator.generate_globals_initts  &  , +    -(!.. 6MFE   E7!4 5 6v4VHI F VY  0+sCrac|jj|}|j|||||j|||||jr |j sF|jr|j ||||j||||j|||y|j r'|j||||j|||yy)zFEmit the PyModuleDef struct for a module and the module init function.N) r private_nameemit_module_methodsemit_module_exec_funcr>r<emit_module_def_slotsemit_module_def_structemit_module_init_funcemit_init_only_func)r^r-rro module_prefixs r_rdz"GroupGenerator.generate_module_defs 22;?    +}fM ""7KO%%$*=*=$$**7M;O  ' 'm L  & &w ] K    ' 'm L  $ $Wk= I !racL|d}t|}|jd|d|jd|dtjdk\r|jdtjdk\r|jd |jd |jd y) N_slotszstatic PyModuleDef_Slot rz{Py_mod_exec, r) r)r rrr)r1rRsys version_info)r^r-rrr} exec_names r_rz$GroupGenerator.emit_module_def_slotss '$[1 4TF'BCOI;c:;   w &   ]    w &   B C,'$rac \|jd|d|jD]}|j|jtk(r#|j j r:t|j|j j|j}t||jrd}nd}t|}|jdj||j|jt |||jd|jd |jy) z3Emit module methods (the static PyMethodDef table).zstatic PyMethodDef zmodule_methods[] = {N METH_FASTCALL METH_VARARGSze{{"{name}", (PyCFunction){prefix}{cname}, {flag} | METH_KEYWORDS, PyDoc_STR({doc}) /* docstring */}},)r}r,prefixflagdocz{NULL, NULL, 0, NULL}r)rRrrer}r/r is_coroutiner7 shortnamerr*r+rrr,rr-) r^r-rrrorr}rrs r_rz"GroupGenerator.emit_module_methodss / >STU"" B}}(BGG~,Eww##%bggrww/@/@"''JD$R)=)=>&%1"5C   :&RXXgmm%rRr<)r^r-rr slots_names r_rz%GroupGenerator.emit_module_def_structs ({ C $ }B  # H      5 6   ? @  )<)<)?&1J    O< =   g &$rac R|jD]}|j|jtk(r$|jj s;|j |j}d}t|j|jj|j}|j||||}d|} |jd| d|jd|jd| d|j||jd |d | d |d |j|y) zEmit insertion of coroutines into the module dict when the module is initialized. Coroutines are wrapped in CPyFunction objects to enable introspection by functions like inspect.iscoroutinefunction(fn). N goto fail;name_ PyObject *z = PyUnicode_FromString("");if (unlikely(!))zif (PyDict_SetItem(rz, (PyObject *)) < 0)) rrer}r/rrrrr7rremit_cpyfunction_instancerR) r^r-roglobalsrrK error_stmtr} wrapper_namename_objs r_emit_coroutine_wrappersz&GroupGenerator.emit_coroutine_wrapperss "" *B}}(BGG~,E77''((9H)J%bggrww/@/@"''JD"<r=r?r;r>rrtype_struct_namerf is_generatedr name_prefixrgenerate_top_level_callri emit_dec_refc_undefined_value)r^r-rrrorr\ impl_name module_staticr module_cachemodule_globals type_structsr type_structrrr}typrundefrs r_rz$GroupGenerator.emit_module_exec_funcs'%[1 YK'9: 2CKRUDU2V$$Y/ k( 88gN (5**;]*S [ 3EFL""   : ?   l +   c " f11 1   C D   l +   c " ,, ,   > ?   l +   c " 6.. .   @ A   l +   c "56    z: ;;M?. Y !,,Y D2=/ DN+: 6     4]OCWX   $$WfnE#% .. QB!2226K    ,- ""@@F@U""^K=#CZP nnW]]; !!GK=8N"OP Q""   :R S++ ;ID#!--dK@K  c4 @--c2E    Sq9 :  ; 1A    !B/ 0 1,'#  ,YKs5'\NRT U   ractt|}d|d}t|dz|jj|<|j ||}|j |d|j d|dd|dd |dd |j |d |d d |d|j d |j d y)zEmit CPyInitOnly_* which creates the module object without executing the body. This allows the caller to set up attributes like __file__ and __package__ before the module body runs. Used for same-group native imports. rrr$rr) { Py_INCREF(rreturn r = PyModule_Create(&module);rN)r4rr'r(rrnrR)r^r-rrinit_only_nameinit_only_declrs r_rz"GroupGenerator.emit_init_only_funcxs /{;%n%5V<7HZ]I]7^$$^488gN >3/=/ &r *m_A &   o1- Im_A &  3"rac8 |jsd|d}n6t|}d|d}t|dz|jj|<|j r>|j |d|d}|jd|d|jd yt|}|jr|j||||j |d|j||}|jd |jd |j d |d d|dd|dd |j |d|dd|dd|jd|d|jd|jd|jrt|j} |jd|jd|jd| d|jd|jd|jdn-|jd |tzd|jd!|jd"td|jd#t|j|j!d$} |jd%| d|jd&|d'|jd(|jd)|jd|jd*|d|jd+|jd|jd,|d-|jd|jd.|j d |d/|d0d|jd1|jd2|jd3|jd|jd|d|j d4|jd|jd5|jd6|jd7|jd8|d|jd9|jd:|jd;|jd<|jd=|jd>|jd?|jd@|jd:|jdA|d|jdB|jd |jdC|j d y)DNrrrr$rrozreturn PyModuleDef_Init(&rrrz#PyObject *initializing_spec = NULL;rr r r r rrrrz modname = PyUnicode_FromString("rz,if (modname == NULL) CPyError_OutOfMemory();z int rv = 0;z.PyObject *mod_dict = PyImport_GetModuleDict();zPyObject *shared_lib = NULL;z(rv = PyDict_GetItemStringRef(mod_dict, "z", &shared_lib);zif (rv < 0) goto fail;zKPyObject *shared_lib_file = PyObject_GetAttrString(shared_lib, "__file__");z'if (shared_lib_file == NULL) goto fail;z2PyObject *shared_lib_file = PyUnicode_FromString("z4if (shared_lib_file == NULL) CPyError_OutOfMemory();z-PyObject *ext_suffix = PyUnicode_FromString("z/if (ext_suffix == NULL) CPyError_OutOfMemory();z __init__.pyzPy_ssize_t is_pkg = zrv = CPyImport_SetDunderAttrs(z0, modname, shared_lib_file, ext_suffix, is_pkg);zPy_DECREF(ext_suffix);zPy_DECREF(shared_lib_file);z0initializing_spec = CPyImport_BeginInitializing(zif (initializing_spec == NULL)z8if (PyObject_SetItem(PyImport_GetModuleDict(), modname, rrr0z) != 0)z2rv = CPyImport_EndInitializing(initializing_spec);zinitializing_spec = NULL;z if (rv < 0)rz* PyObject *exc_type, *exc_val, *exc_tb;z. PyErr_Fetch(&exc_type, &exc_val, &exc_tb);z if (modname == NULL) {z( modname = PyUnicode_FromString("z4 if (modname == NULL) CPyError_OutOfMemory();z }z8 PyObject_DelItem(PyImport_GetModuleDict(), modname);z PyErr_Clear();z Py_DECREF(modname);z$ if (initializing_spec != NULL) {z5 CPyImport_EndInitializing(initializing_spec);z PyErr_Clear();z Py_CLEAR(z- PyErr_Restore(exc_type, exc_val, exc_tb);r)r<r3rr'r(r>rnrRr1rrrr6r)intrendswith) r^r-rrr\ndef_name exec_funcrshared_lib_mod_nameis_pkgs r_rz$GroupGenerator.emit_module_init_funcs"""2;-vFK -A&qc0K.? c@Q.RGOO ( ( +    {C 0'/H    9(2F G   c " $[1     $ $Wk= I ;,88gN 56?@=/ &r *m_A &    o1- IM?* 5  <[MMNHI-( ??"1$//"B    N O   < =   :;N:OO_`    6 7   ]    G H   D[S]E]D^^ab    T UI*UXYZKLT&&{3<<]KL0:;,]O;k l  237823 L]O[]^_:;*+F}oU[ \  *+./T)Am_GDFVWNO56-(*+GM?!457# #FGJK67D[MQTUVPQ'"TU./34@AQR23'"M-;<IJ#.)3ract|jD]G}|jtk(s|j d|j |j dddyy)z8Generate call to function representing module top level.zchar result = z();zif (result == 2)rN)reversedrr}r/rnr)r)r^ror-rs r_rz&GroupGenerator.generate_top_level_calls_6++, Bww.(""$W%A%A"''%J$K3O&$  racgi|jjjD]\}}t|d|<dfd D] }| S)a~Topologically sort the declaration dict by dependencies. Declarations can require other declarations to come prior in C (such as declaring structs). In order to guarantee that the C output will compile the declarations will thus need to be properly ordered. This simple DFS guarantees that we have a proper ordering. This runs in O(V + E). Fc|}|jryt|jjD] }| j |jd|_y)NT)r]rwr\rrf)r}rchild_toposort_visitmarked_declarationsrs r_rz=GroupGenerator.toposort_declarations.._toposort_visitsZ&t,Dyy 0 0 = => '& ' MM$** +DIra)r}strrcrd)r'r(rrZ)r^rvr}rrrs @@@r_roz$GroupGenerator.toposort_declarations so<>LL--335 ADAq%6q%%@  " A ( "D D ! " raNrcd|vr||}n|jdd\}}||d|}|sd}n |d|dg}||jjvr(t|d||jj|<yy)N[rrr$rr)r7r'r(r)r^ type_spacedr}rbaseabrrs r_rzGroupGenerator.declare_global+s k !!]4&)D$$S!,DAqSas#DDfC }A./D t||00 0.?4& QU.VDLL % %d + 1rac|jd|}||jjvr)td|dd|jj|<yy)Nrrr$Tr%)rr'r(r)r^rr-rs r_r_z'GroupGenerator.declare_internal_globals;sR)))[A dll77 75F[M+$6DLL % %k 2 8rac8|j|dzdtS)N __internalr)rr,)r^rr-s r_rz*GroupGenerator.module_internal_static_nameBs"";#=tM"ZZrac||jvrv|j||}|jd|dt|}||jj vr-t d|dd|dg|jj |<|j|dt}|jd ||jj|d fy) Nz CPyModule *NULLrzCPyImportState r$z = {0};r$rzCPyModuleCache z(CPyModuleCache)Py_None) r~rrr2r'r(rrr,r;rf)r^rr-internal_static_name state_namers r_r^zGroupGenerator.declare_moduleEs $,, &#'#C#CKQX#Y    /CQW  X1+>J!:!::8I%j\3_ZLXa;b:c9 ))*5))+tM)R  -{;   +/H!IJrac|jJt|j}||jjvr.t d|dd|dg|jj|<yy)NzCPyModuleLockAPI *r$rr$)rr5r'r(r)r^r}s r_r\z&GroupGenerator.declare_module_lock_apiVsk***#DOO4 t||00 0.?$TF!,6Hh4W3X/DLL % %d + 1rac6|D]}|j||yrn)r^)r^impsr-imps r_r`zGroupGenerator.declare_imports^s! .C   W - .rac |D]c\}}|j||}t|j||d|j||||gd|jj |<eyr#)rr ctype_spacedfinal_definitionr'r()r^rorir-r}rrs r_rhzGroupGenerator.declare_finalsbsv% ID#!--dF;K8I'',-k]!<&&vtS'BC!9GOO ( ( 5 racz|j||}|j|}|j||d|dS)Nrr$)rc_initializer_undefined_valuer5)r^ror}rr-r undefineds r_r6zGroupGenerator.final_definitionmsG))$7 99#> &&s+,[MYKqIIracL|j|d}|jd|y)Nr)rr)r^ identifierr-rs r_declare_static_pyobjectz&GroupGenerator.declare_static_pyobjectss$$$Z6 L&1rac|D]H}|j||t}td|dd|dgd|jj|<Jy)Nrrr$rFr%)rr0rr'r()r^rorlr-r}rs r_rkz GroupGenerator.declare_type_varsws_" D!--dF?-SK8I[M+k](34"9GOO ( ( 5 ra)r~dict[str, ModuleIR]rzdict[str, str]r str | Nonervdict[str, str | None]rrMrxrOrcrd)rcr )rclist[tuple[str, str]])rcrd)rrrrrcrd)r-rrcrd)r-rrr rorDrcrd)r-rrr rr rcrd) r-rrr rr rorDrcrd)r-rrr rr rcrd)r-rrorDrr rcrd)rorDr-rrcrd)rczlist[HeaderDeclaration])r%r r}r rr?rcrd)rr r-rrcrd)rr r-rrcr )r2z Iterable[str]r-rrcrd)ror rizIterable[tuple[str, RType]]r-rrcrd) ror r}r rrIr-rrcr )r;r r-rrcrd)ror rlz list[str]r-rrcrd) rerfrgr`propertyrArCrr]rsrtrprdrrrrrrrrrorr_rr^r\r`rhr6r<rkrirar_rrss &1$&1%&1 &1 ) &1  &1*&1 &1POO^^j X\@:%xFPD*J(  /2 AD  *-0ADNV :-0AD 0*0w w -0w ADw NVw w r0o o -0o ADo o b >IMWW&)W;EW W [K".  (C NU   J 2rarTcVgtdfd D] }| S)zUTopologically sort a dict from item to dependencies. This runs in O(V + E). cx|vry|D] }| j|j|yrn)rfr)itemrrrvisitvisiteds r_rGztoposort..visitsA 7? $Z E %L   d Dra)rFrCrcrd)r)rrFrrGrHs` @@@r_toposortrIs: FeG d  Mrac||j0|jdk(ry|jdk7xr|jdk7Sy)N__call__Tr`__new__)rer})rr+s r_r*r*s; }} 77j ww*$=I)== rac|jD]?}|jD].}t|ts|j |j 0Ay)zStore all Python literal object refs in fn. Collecting literals must happen only after we have the final IR. This way we won't include literals that have been optimized away. N)blocksopsrrHrecord_literalvalue)rrZblockops r_rYrYsF 2)) 2B"k*''1 22racg}|jd|D]"}|jdt|zdz$|jddj|S)Nz{ z z, rr)rfrr) componentsrss r_rrsZ F MM% @ f3A66>?@ MM# 776?ra)NN)r|list[BuildSource]rzrrxrOr{rrzFileSystemCache | Nonerr?rcr) rlist[MypyFile]rrrrKrxrOrr9rcrE) rrrrKrxrOrr9rcrE) r{rr~rErrrrKrxrOrc'dict[str | None, list[tuple[str, str]]])rrWrrrcrA)rr rr rzrrcr )rrrcr ) r~rErrrvr@rrYrcrd) rrXrrrrKrrGrcrE)r~r>rczset[SourceDep])r~r>rrbrcr) rrrxrOrr9r{rrcz,tuple[ModuleIRs, list[FileContents], Mapper])rrCr-rrcrd)rr r}r rcr )rr rcr )rzdict[T, set[T]]rczlist[T])rrCr+ztuple[int, int]rcrb)rrCrZr(rcrd)rUz list[bytes]rcr )rh __future__rrrrcollections.abcrtypingr mypy.buildrrrr r r r r mypy.errorsr mypy.fscacher mypy.nodesrr mypy.optionsr mypy.pluginrr mypy.utilrrmypyc.analysis.capsule_depsrrmypyc.codegen.cstringrmypyc.codegen.emitrrrrrmypyc.codegen.emitclassrr r!mypyc.codegen.emitfuncr"r#mypyc.codegen.emitwrapperr$r%r&r'mypyc.codegen.literalsr( mypyc.commonr)r*r+r,r-r.r/r0r1r2r3r4r5r6r7 mypyc.crashr8 mypyc.errorsr9 mypyc.ir.depsr:r;r<r=r>r?r@rArBmypyc.ir.func_irrCmypyc.ir.module_irrDrErF mypyc.ir.opsrGrHmypyc.ir.rtypesrImypyc.irbuild.mainrJmypyc.irbuild.mapperrKmypyc.irbuild.preparerL mypyc.namegenrMrN mypyc.optionsrO&mypyc.transform.borrow_generator_attrsrP mypyc.transform.copy_propagationrQmypyc.transform.exceptionsrR mypyc.transform.flag_eliminationrSmypyc.transform.log_tracerTmypyc.transform.lowerrUmypyc.transform.refcountrVmypyc.transform.spillrWmypyc.transform.uninitrXtuplelistr Groupr FileContentsrZrkrrrrrrrr rrrr!r.r3r8rrCrIr*rYrrirar_rs(N # $   %() 3-^6cbS ,"%   $GG/!''/6)I@@@@*=/7, d;t+, eE#s(O$ b&bT'+#   &   $   4G G G G& G  G  GT# #!'#;J#TZ##L- - - -  - & - - -`$.94W C2& 2& 2&%2& 3 2&  2&j !,6<CL$  %@ %@+:%@DJ%@TZ%@1%@P$.3 KK\  CL0 2ra