a 7Sic@sUdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZ ddlmZddlmZmZmZddlmZddlmmZddl mZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'e j(dddkrdd l m)Z)n dd l*m)Z)e%e+d <zddl,Z,e,j-Z-Wn"e.ybddl/Z/e/j-Z-Yn0e0Z1d e+d <d dZ2de3dddZ4ddZ5ddZ6e7dddZ8e"e9dddZ:ddZ;ddZGd#d$d$e?Z@d%d&ZAd'd(ZBGd)d*d*ejCZDdd,d-ZEd.d/ZFd0d1ZGe7dd2d3ZHe7dd4d5ZIe7dd6d7ZJd8d9ZKd:d;ZLddd<d?ZOd@dAZPdBdCZQdDdEZRdFdGZSdddHdIZTe$e9e3fddJdKZUiaVe e9e e9e"effe+dL<iZWdMdNZXdOdPZYe7ddQdRZZe7ddSdTZ[e7ddUdVZ\dWdXZ]dYdZZ^e7dd[d\Z_e j`jabrdd]lmcZcdd^ldmeZee7dd_d`Zfe7ddadbZgne7ddcdbZge7ddddeZhGdfdgdge?ZieiZjekddhD]Zlejemdiel<qe7ddjdkZnde9ddmdnZododpZpdqdrZqe9e"e9e$edsfdtdudvZrejsdwdxZtdddydzZue7dd{d|Zvddd}d~ZwddZxddZyddddZzddddZ{e7dddZ|e7dddZ}Gdddej~ZddZdS)z The weak_script annotation needs to be here instead of inside torch/jit/ so it can be used in other places in torch/ (namely torch.nn) without running into circular dependency problems N)dedent)Future)get_source_lines_and_file parse_def fake_range) AnyCallableDictGenericListOptionalTupleTypeTypeVarUnion))FinalLockTypez8weakref.WeakKeyDictionary[Callable, Dict[str, Callable]]boolean_dispatchedcsBfddtttfdfdd fddfdd S) a_ Creates a resolution callback that will look up qualified names in an environment, starting with `lookup_base` for the base of any qualified names, then proceeding down the lookup chain with the resolved object. You should not use this directly, it should only be used from the other createResolutionCallbackFrom* functions. csNd|vr@|d}|d}d|dd}t||}||St||SdS)N.r)splitjoingetattr)qualified_namemodulepartsbaseZremaining_piecesZ module_value)lookupInModuleO/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/_jit_internal.pyr ;s   z7createResolutionCallbackFromEnv..lookupInModulereturncs"d}|t|kr&||dvr&|d7}q|d|dkr>d|fS|d||}|dusrJd|d||t|ks||dkr||fS||dksJg}||dkrd}|d7}||d|\}}||||7}qt|dkr |t||dfS||d|dfSdS) Nr),[]rz()r!zUnresolvable type r&r')lenstripappendtuple)exprrirrZpart_lenpart)r parseNestedExprr!r"r/Es(    z8createResolutionCallbackFromEnv..parseNestedExprcsBz(||\}}|t|ks$Jd|WSty<YdS0dS)Nz;whole expression was not parsed, falling back to c++ parser)r( Exception)r,rvalueZ len_parsed)r/r!r" parseExpras  z2createResolutionCallbackFromEnv..parseExprcs |SNr!)r,) lookup_baser2r!r"oz1createResolutionCallbackFromEnv..)r rint)r4r!)r r4r2r/r"createResolutionCallbackFromEnv2s  r8) frames_upcslt}d}||dkr4|dus$J|j}|d7}q |dus@J|j|jGfdddt}t|S)aZ Creates a function which, given a string variable name, returns the value of the variable in the scope of the caller of the function which called createResolutionCallbackFromFrame (by default). This is used to enable access in-scope Python variables inside TorchScript fragments. frames_up is number of additional frames to go up on the stack. The default value is 0, which correspond to the frame of the caller of createResolutionCallbackFromFrame. Also for example, if frames_up is set to 1, then the frame of the caller's caller of createResolutionCallbackFromFrame will be taken. For example, the following program prints 2:: def bar(): cb = createResolutionCallbackFromFrame(1) print(cb("foo")) def baz(): foo = 2 bar() baz() rrNcseZdZfddZdS)z.createResolutionCallbackFromFrame..envcs:|vr|S|vr |S|ttvr6tt|SdSr3)dirbuiltinsrselfkey f_globalsf_localsr!r" __getattr__s  z:createResolutionCallbackFromFrame..env.__getattr__N__name__ __module__ __qualname__rBr!r?r!r"envsrG)inspect currentframef_backrAr@objectr8)r9framer-rGr!r?r"!createResolutionCallbackFromFramers     rMcCs:i}||jt|jjD]\}}|j|j||<q|S)zC Get a dictionary of closed over variables from a function )update __globals__ enumerate__code__ co_freevars __closure__ cell_contents)fncapturesindexZ captured_namer!r!r" get_closures  rXcs&t|Gfdddt}t|S)z Create a resolutionCallback by introspecting the function instead of looking up the stack for the enclosing scope cseZdZfddZdS)z;createResolutionCallbackFromClosure..closure_lookupcs<|vr|Stt|r$tt|Stt|r8tt|SdSr3)hasattrtypingrr;r<closurer!r"rBs    zGcreateResolutionCallbackFromClosure..closure_lookup.__getattr__NrCr!r[r!r"closure_lookupsr])rXrKr8)rUr]r!r[r"#createResolutionCallbackFromClosures r^r#csXtr dStjjtttf}t|r*dSj}fdd|D}dd|D}t |S)NFcs(g|] }tt|drt|qSr3rH isroutiner.0nameclsr!r" r6z%can_compile_class..cSsg|]}t|dqS)rQ)rY)rbrUr!r!r"rfr6) is_ignored_fntorchnnModuler+listr0 issubclass__dict__all)reZignored_builtin_classesnamesfnsZhas_coder!rdr"can_compile_classs rqcCs`zt|}Wnty$gYS0g}|jD]&\}}|j|jksPgS||q4|S)aU Gets names of all POSITIONAL_OR_KEYWORD arguments for callable `fn`. Returns an empty list when other types of arguments are present. This is used by `torch.jit.trace` to assign meaningful argument names to traced functions and modules. Args: fn: A callable. Returns: Argument names: List[str] )rH signaturer0 parametersitemskindPOSITIONAL_OR_KEYWORDr*)rUZcallable_signatureZargument_namesrcparamr!r!r"get_callable_argument_namess    rxcCst|tjr|jSt|tjr4dt|j|jgSt|tj rrt j dkrP|j n|j j}t|jdt|dSt|tj rddd|jDSt|tjst|tjr|jSdS) z Convert an AST node containing a type annotation to the string present in the source that represents the same annotation. r)r r&r'r%cSsg|] }t|qSr!)get_annotation_str)rbeltr!r!r"rf2r6z&get_annotation_str..N) isinstanceastNameid Attributerrzr1attr Subscriptsys version_infoslicer eltsConstant NameConstant) annotationZsubscript_slicer!r!r"rz$s    rzcCst|}dd|jD}t|}tt|}t|j dksVt |j dtj sft d|d|j d}i}|j j D]<}|jrt|jnd}|durq||j} | |vr||| ||<q|t|j} | du} |j} | tjjuot | t } | r| r| || <|S)a Get a dictionary containing type resolution mappings necessary to resolve types for the literal annotations on 'fn'. These are not considered to be closed-over by fn and must be obtained separately (e.g. using this function). Args: fn: A callable. Returns: A Dict[str, Any] containing a mapping from the literal annotations used on fn to the Python objects they refer to. cSs2i|]*\}}|jtjjurt|jts||jqSr!)rrH Parameteremptyr|str)rbrc parameterr!r!r" Lsz*get_type_hint_captures..rrz Expected z to be a functionN)rHrrrsrt getsourcer}parserr(bodyr| FunctionDef RuntimeErrorargsrrzargreturnsreturn_annotationrrr)rUrrZ name_to_typesrcafZannotation_to_typerZarg_annotation_strarg_nameZliteral_return_annotationZvalid_literal_annotationrZvalid_return_annotation_typer!r!r"get_type_hint_captures:s0      rcsNfddjD}i|D] }t|t|qfdd}|S)z This looks at all the methods defined in a class and pulls their closed-over variables into a dictionary and uses that to resolve variables. cs&g|]}tt|rt|qSr!r_rardr!r"rfr6z;createResolutionCallbackForClassMethods..cs |vr|Stt|dSdSr3)rr;)r>)rVr!r"lookup_in_classsz@createResolutionCallbackForClassMethods..lookup_in_class)rmrNrXr)rerprUrr!)rVrer"'createResolutionCallbackForClassMethodss rc sfdd}jdur4jdur4j}|_nDjdurVjdurVj}|_n"jdurpjdurpd}ntd||_|dur||_|dur||_|dt|<|S)z Dispatches to either of 2 script functions based on a boolean argument. In TorchScript, the boolean argument must be constant so that the correct function to use can be determined at compile time. csNd}|vr|}nt|kr*|}|r<|i|S|i|SdSNF)r()rkwargsZ dispatch_flag arg_indexrif_falseif_truer!r"rUs  zboolean_dispatch..fnNz&only one function can have a docstring)rrrWdefaultr)__doc__rrErDr) rrrrr module_name func_namerUdocr!rr"boolean_dispatchs,  rc@s$eZdZdZdZdZdZdZdZdS)FunctionModifierszn Used to denote the behavior of a function in TorchScript. See export() and ignore() for details. z:unused (ignored and replaced with raising of an exception)z>ignore (leave as a call to Python, cannot be torch.jit.save'd)z7export (compile this function even if nothing calls it)z>default (compile if called from a exported function / forward)zNif this method is not scripted, copy the python method onto the scripted modelN) rDrErFrUNUSEDIGNOREEXPORTDEFAULTCOPY_TO_SCRIPT_WRAPPERr!r!r!r"rsrcCs tj|_|S)a This decorator indicates that a method on an ``nn.Module`` is used as an entry point into a :class:`ScriptModule` and should be compiled. ``forward`` implicitly is assumed to be an entry point, so it does not need this decorator. Functions and methods called from ``forward`` are compiled as they are seen by the compiler, so they do not need this decorator either. Example (using ``@torch.jit.export`` on a method): .. testcode:: import torch import torch.nn as nn class MyModule(nn.Module): def implicitly_compiled_method(self, x): return x + 99 # `forward` is implicitly decorated with `@torch.jit.export`, # so adding it here would have no effect def forward(self, x): return x + 10 @torch.jit.export def another_forward(self, x): # When the compiler sees this call, it will compile # `implicitly_compiled_method` return self.implicitly_compiled_method(x) def unused_method(self, x): return x - 20 # `m` will contain compiled methods: # `forward` # `another_forward` # `implicitly_compiled_method` # `unused_method` will not be compiled since it was not called from # any compiled methods and wasn't decorated with `@torch.jit.export` m = torch.jit.script(MyModule()) )rr_torchscript_modifierrUr!r!r"exports*rcCsDt|tr8|}t|jdtj|jr4t|jdtj|Stj|_|S)a This decorator indicates to the compiler that a function or method should be ignored and replaced with the raising of an exception. This allows you to leave code in your model that is not yet TorchScript compatible and still export your model. Example (using ``@torch.jit.unused`` on a method):: import torch import torch.nn as nn class MyModule(nn.Module): def __init__(self, use_memory_efficient): super(MyModule, self).__init__() self.use_memory_efficient = use_memory_efficient @torch.jit.unused def memory_efficient(self, x): import pdb pdb.set_trace() return x + 10 def forward(self, x): # Use not-yet-scriptable memory efficient mode if self.use_memory_efficient: return self.memory_efficient(x) else: return x + 10 m = torch.jit.script(MyModule(use_memory_efficient=False)) m.save("m.pt") m = torch.jit.script(MyModule(use_memory_efficient=True)) # exception raised m(torch.rand(100)) r)r|propertysetattrfgetrrfsetr)rUpropr!r!r"unuseds% rc@s(eZdZddZeeeddddZdS)_IgnoreContextManagercKsdSr3r!)r=rr!r!r"__init__3sz_IgnoreContextManager.__init__N)exc_type exc_value tracebackr$cCsdSr3r!)r=rrrr!r!r"__exit__6sz_IgnoreContextManager.__exit__)rDrErFrrrr!r!r!r"r2srFc svtr}tj|_|Stts0td|dd}|rTtj dt d|nrftj dt dfdd}|S) a# This decorator indicates to the compiler that a function or method should be ignored and left as a Python function. This allows you to leave code in your model that is not yet TorchScript compatible. If called from TorchScript, ignored functions will dispatch the call to the Python interpreter. Models with ignored functions cannot be exported; use :func:`@torch.jit.unused ` instead. Example (using ``@torch.jit.ignore`` on a method):: import torch import torch.nn as nn class MyModule(nn.Module): @torch.jit.ignore def debugger(self, x): import pdb pdb.set_trace() def forward(self, x): x += 10 # The compiler would normally try to compile `debugger`, # but since it is `@ignore`d, it will be left as a call # to Python self.debugger(x) return x m = torch.jit.script(MyModule()) # Error! The call `debugger` cannot be saved since it calls into Python m.save("m.pt") Example (using ``@torch.jit.ignore(drop=True)`` on a method): .. testcode:: import torch import torch.nn as nn class MyModule(nn.Module): @torch.jit.ignore(drop=True) def training_method(self, x): import pdb pdb.set_trace() def forward(self, x): if self.training: self.training_method(x) return x m = torch.jit.script(MyModule()) # This is OK since `training_method` is not saved, the call is replaced # with a `raise`. m.save("m.pt") .. testcleanup:: import os os.remove('m.pt') zCArgument to @torch.jit.ignore must be a bool or a function but got drop_on_exportNzignore(drop_on_export=True) has been deprecated. TorchScript will now drop the function call on compilation. Use torch.jit.unused now. {})categoryzzignore(True) has been deprecated. TorchScript will now drop the function call on compilation. Use torch.jit.unused now. {}csrtj|_ntj|_|Sr3)rrrrrdropr!r" decorators zignore..decorator) callablerrrr|boolrpopwarningswarn FutureWarning)rrrUrrr!rr"ignore9s(>   rcCs tj|_|Sr3)rrrrr!r!r"_copy_to_script_wrappersrcCsBt|D]4}t||rt||}t|rt|tjurdSqdS)NTF)r:rYrrget_torchscript_modifierrr)modrcitemr!r!r"module_has_exportss   rcCst|}|durdS|tjuSr)rrr)rUrr!r!r" should_dropsrcCst|}|tjup|tjuSr3)rrrr)rUrr!r!r"rgsrgcCsttj||ddtS)N)r)r|rHgetattr_static staticmethodrerUr!r!r" is_static_fnsrcCst||jSr3)rHr__func__rr!r!r" get_static_fnsrcCs*t|s dSt|dr|j}t|dtjS)Nrr)rrYrrrrrr!r!r"rs  rcCst|}|durdS||_dSr3)rr)orignewrr!r!r"copy_torchscript_modifiersr_overloaded_fnsaP Example usage of overload function: @torch.jit._overload def my_function(x: type0) -> type0: # decl 1 pass @torch.jit._overload def my_function(x: type1) -> type1: # decl 2 pass def my_function(x): # implementation if isinstance(x, type0): return x elif isinstance(x, type1): return x c CsBt|\}}}d|dt|d|d|d d|dtS)NzImplementation for the z "zk" is missing. Please make sure a definition is provided and defined after all overload declarations. File "z", line z:  )r_qualified_namer_OVERLOAD_EXAMPLE)ruobj sourcelines file_linenofilenamer!r!r",get_overload_no_implementation_error_messagesrc Csz t|}Wn8tyD}z td|dWYd}~dSd}~00|jjdj}dd}dd}t|dks||ds||dsd }|d |j d dd 7}|d t 7}t |dS) Nz=Unable to retrieve source for @torch.jit._overload function: rrcSs t|tjSr3)r|r}Passxr!r!r"is_passsz%_check_overload_body..is_passcSst|tjot|jtjSr3)r|r}Exprr1Ellipsisrr!r!r" is_ellipsissz)_check_overload_body..is_ellipsisrzHOnly `pass` statement or `...` can be the body of overload declaration: rrz$ <- Expecting `pass` or `...` here! ) rOSErrorrrr}rr(rsourcerrr)funcZ parsed_deferrrmsgr!r!r"_check_overload_bodys $ rcCs<t|t|}t|}|dur.g}|t|<|||Sr3)rrrgetr*)r qual_nameZfn_overload_listr!r!r" _overloads  rcCs t|Sr3)rrrr!r!r"_get_fn_overloads srcCs t|=dSr3)rrr!r!r"_clear_fn_overloadssrcCsLt}tdD]}|dus J|j}q|dus4J|jj}|jj}||fSNr)rHrIrangerJf_codeco_nameco_firstlineno)method current_framer- class_nameline_nor!r!r"get_class_name_linenos   r_overloaded_methodscCst|t|}t|d}|dur0i}|t|<t|\}}||d}|durjg}|||<|t||f<nt||f}||krtd|||S)NzmCannot currently overload the same method name in two different classes with the same name in the same module)rrrrr_overloaded_method_class_filenorr*)rrclass_name_maprrZmethod_overloadsZexisting_linenor!r!r"_overload_method.s"     rcCst|dsdSt|}t|d}|dur.dS||jd}|durHdSt|d}t|d}|tt|d}||kr||kstdt||S)NrDrrzLOverloads are not useable when a module is redeclared within the same file: ) rYrrrrDrr(r0r)rZ mod_classrrZ overloadsZmethod_line_noZmod_class_filenoZmod_end_filenor!r!r"_get_overloaded_methodsFs    rcCsH|turtdt|dsdS|jdkoFt|ddtupFt|ddtuS)Nr rEFrZ __origin__)r 'raise_error_container_parameter_missingrYrErr+annr!r!r"is_tupleZs  r cCsH|turtdt|dsdS|jdkoFt|ddtupFt|ddtuS)Nr rEFrZr)r rrYrErrkr r!r!r"is_listes  r cCsH|turtdt|dsdS|jdkoFt|ddtupFt|ddtuS)Nr rEFrZr)r rrYrErdictr r!r!r"is_dictos  rcCs4|turtdt|do2|jdko2t|ddtuS)NrrErZr)rrrYrErr r!r!r"is_unionys rcCs8|turtddd}dd}||p6t|o6||S)Nr cSs$t|do"|jdko"t|ddtuS)NrErZr)rYrErr r r!r!r"is_optional_as_optionals  z,is_optional..is_optional_as_optionalcSs|j}t|dkod|vSr)__args__r()r Zann_argsr!r!r"is_union_as_optionalsz)is_optional..is_union_as_optional)r rr)r rrr!r!r" is_optionals rcCs |turtdt|ddtuS)Nz_Attempted to use Future without a contained type. Please add a contained type, e.g. Future[int]r)rrrr r!r!r" is_futures r)RRef)PyRRefcCs |turtdt|ddtuS)Nz[Attempted to use RRef without a contained type. Please add a contained type, e.g. RRef[int]r)rrrr r!r!r"is_rrefs rcCs t|tSr3)r|rrr!r!r"is_rref_instancesrcCsdSrr!rr!r!r"rscCs(|jdvo&t|ddtup&t|ttS)N>rZtyping_extensionsr)rErrr|typer r!r!r"is_finals rc@seZdZddZdS)BroadcastingListClscCsdSr3r!)r=typesr!r!r" __getitem__szBroadcastingListCls.__getitem__N)rDrErFrr!r!r!r"rsrrZBroadcastingListcCsdS)a Function that returns True when in compilation and False otherwise. This is useful especially with the @unused decorator to leave code in your model that is not yet TorchScript compatible. .. testcode:: import torch @torch.jit.unused def unsupported_linear_op(x): return x def linear(x): if torch.jit.is_scripting(): return torch.linear(x) else: return unsupported_linear_op(x) Fr!r!r!r!r" is_scriptingsr TcCst|dr|jSt|tjjr$|jSt|ddr8|j}nt|t j rL|j }nt d|dkr`d}|j }|dkrt|jS|durt d|dt|r|d d }|d d }|r|d krd }nd|}d|vrt d|d|d|d|S)N_jit_override_qualnamerDz)Could not get name of python class objectzZ_lambdaztorch._classesz(Could not get qualified name for class 'z': __module__ can't be None.<_>__main__Z __torch__z __torch__.rz': 'z' is not a valid identifier)rYr!r|rh_CScriptFunctionrrrDenumEnumrcrrEpackage_manglingZ is_mangledreplace)rZ mangle_namercrr!r!r"rs8        rcCst|s dSt|Sr3)rrrrr!r!r"_try_get_dispatched_fnsr,csttrtdsJtdr8fddjD}ng}g}td}jD]H}|r|jvrtjjj|t }| |qP| tj j qPtjj||fS)N_fields_field_defaultscs g|]}|jvrj|qSr!)r.)rbfieldrr!r"rf!s z/_get_named_tuple_properties..__annotations__)rlr+rYr-r0rhjit annotationsZ ann_to_typerr*r& TensorType getInferredrrD)rdefaultsr2Zhas_annotationsr/Zthe_typer!rr"_get_named_tuple_propertiess     r6.) unqual_name field_namesr5cCs8tjdkr t||}||j_ntj|||d}||S)N)rrr)r5)rr collections namedtuple__new__ __defaults__)tr7r8r5 TupleTyper!r!r"_create_named_tuple1s    r?ccs8tj}tjdddVtj|d|ddSNrr)rhr&_jit_get_emit_hooks_jit_set_emit_hooks)hooksr!r!r"_disable_emit_hooks:s rDcCs dddd}dddd}dS)Nr#cSstj|_tjdddSr3)rhr&rArCrB)r=r!r!r" __enter__Cs z0_disable_emit_hooks_decorator..__enter__cWstj|jd|jddSr@)rhr&rBrC)r=rr!r!r"rGsz/_disable_emit_hooks_decorator..__exit__r!)Z_DecoratorContextManagerrErr!r!r"_disable_emit_hooks_decoratorBsrFcCst|sdSt|tSr)rHisclassrlr0rr!r!r" _is_exceptionJs rHcCs*|dkrtdtd|d|ddS)Nr z]Attempted to use Dict without contained types. Please add contained type, e.g. Dict[int, int]zAttempted to use z= without a contained type. Please add a contained type, e.g. z[int])r target_typer!r!r"rOsrcCs t|ddS)NrrrIr!r!r" get_origin]srLcCs t|ddS)NrrKrIr!r!r"get_argsasrMcCsj|tus|turtdnL|tus*|tur4tdn2|tusD|turNtdn|dus^|turftddS)Nr r r r )r rkrr r+r r r rIr!r!r"check_args_existes   rNcCs&|gks|iks|dkr"tddS)Nr!zThe inner type of a container is lost when calling torch.jit.isinstance in eager mode. For example, List[int] would become list and therefore falsely return True for List[float] or List[str].)rrrr!r!r"check_empty_containerspsrOcCs t|}t||tus |tur~t|t|ts6dSt|d}t|}|D]*}|rht||sxdSqNt||sNdSqNdS|tus|t urt|t|t sdSt|d}t|d}| D]J\}} t||sdSt|} | rt| |sdSqt| |sdSqdS|t us*|t urt|t|t sBdSt|} t |t | kr`dSt|| D]>\}} t| } | rt|| sdSnt|| sjdSqjdS|tur|durdSt|}|D]4}t|}|rt||St||rdSqdS)NFrTr)rLrNrkr rOr|rMcontainer_checkerr r rtr r+r(zipr)rrJ origin_typearg_typeZ arg_originelZkey_typeZval_typer>valZ val_originZ arg_typesZel_typeZ el_originZ inner_typesr=Zt_originr!r!r"rP{sr                  rPcCsft|tjjr>t|ts td|D]}t||r$dSq$dSt|}|rTt||St |t||S)NzPThe second argument to `torch.jit.isinstance` must be a type or a tuple of typesTF) r|r9abc Containerr+r _isinstancerLrPrN)rrJZt_typerRr!r!r"rXs   rXcs0eZdZeejdfdd ZddZZS)_TensorExtractor)tensorscstj|i|||_dSr3)superrrZ)r=rZrr __class__r!r"rsz_TensorExtractor.__init__cCsft|tjr|j|dSt|tr*dSt|tss   0   @2:F. .2 ^           C    >