o h@ @sddlZddlZddlZddlZddlmZmZddlmZm Z m Z ddl Z ddl m mZddl mZmZddlmZdKddZejGd d d ZGd d d Zd edefddZdedeeeffddZdedefddZdedefddZdedefddZ dedefddZ!dedefdd Z"defd!d"Z#d#d$Z$dej%d%eed&fd'e&eefdeeej'effd(d)Z(d*d+Z)dedefd,d-Z*defd.d/Z+d0d1Z,dej%fd2d3Z-dej%fd4d5Z.dej%defd6d7Z/dej%de edffd8d9Z0 :dLd%eed'e&eefd;edee j1fdd?fd@dAZ3GdBdCdCZ4dDe j1de j1fdEdFZ5de j6jdefdGdHZ7dej%dee8ee8effdIdJZ9dS)MN)IterableIterator)AnyCallableUnion)_C_utils_internal) OpOverloadcCstjdt|ddS)Nz}Python torch.library APIs do nothing under torch::deploy (multipy). Please instead use C++ custom operator registration APIs. stacklevel)warningswarnRuntimeWarningr rh/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torch/_library/utils.py warn_deploys  rc@s*eZdZUdZeed<eed<ddZdS)Kernelz$Models a (function, source location)funcsourcecOs|j|i|SN)r)selfargskwargsrrr__call__szKernel.__call__N)__name__ __module__ __qualname____doc__r__annotations__strrrrrrrs  rc@s(eZdZdZdefddZd ddZdS) RegistrationHandlez2Does something when someone calls .destroy() on it on_destroycCs ||_dSr _on_destroy)rr"rrr__init__&s zRegistrationHandle.__init__returnNcCs |dSrr#rrrrdestroy)s zRegistrationHandle.destroy)r&N)rrrrrr%r(rrrrr!#sr!r r&cCs&tt|}|jd|j}|S)zGet a string that represents the caller. Example: "/path/to/foo.py:42" Use stacklevel=1 to get the caller's source Use stacklevel=2 to get the caller's caller's source etc. :)inspect getframeinfosys _getframefilenamelineno)r framerrrr get_source-s r1qualnamecCs6|d}t|dkrtd|d|d|dfS)Nz::zAExpected `qualname` to be of the form "namespace::name", but got zf. The qualname passed to the torch.library APIs must consist of a namespace and a name, e.g. aten::sinr)splitlen ValueError)r2splitsrrrparse_namespace;s  r9cCsHt|\}}d|vr|d\}}nd}ttj|}t||}t||S)N.default)r9r5getattrtorchops)r2 namespacenameoverloadnspacketrrr lookup_opGs    rDopcCst|tsJ|jdvS)N>atenprimprims) isinstancer r?)rErrr is_builtinRs rJschemacCsTdd}t|tjjr||Sddlm}t|tr||}t||s&J||S)zCheck if the schema is functional. An operator is functional if: - it does not mutate any of its inputs - it does not return a view on any of its inputs - it has at least one return cSsD|jrdS|j}t|dkotdd|D}|rdS|js dSdS)NFrcss$|] }|jduo |jj VqdSr) alias_infois_write).0rrrr ds z>is_functional_schema..is_functional..T) is_mutablereturnsr6any)rKretsis_non_mutating_viewrrr is_functional`sz+is_functional_schema..is_functionalr)FunctionSchema)rIr=rrWtorchgen.modelr parse)rKrVrWrrris_functional_schemaWs     rZtypc Csh|ttjkp3|tttjkp3|tttjkp3|ttttjkSr)rListType TensorTypeget OptionalTyper[rrris_tensorlist_like_typezsracCs"|tjkp|ttjkSr)rr]r^r_r`rrris_tensor_like_types"rbcCs|jdkrdS|j}t|jdksdS|jdjdurdS|jdjj}t|dkr,dStt|}t|jdkr;dS|jd}|jdurGdS|jj sMdS|jj}t|dkrYdS|tt|krcdS|jddD] }|jdurtdSqjdS)aNCheck if an op is an inplace aten op, i.e. it mutates and returns the first arg. TODO: torchgen/model.py's FunctionSchema.parse is the source of truth for this, but not all PyTorch builds have torchgen (due to the yaml dependency being weird). Figure this out. Example: add_(Tensor(a!) x, Tensor y) -> Tensor(a) rFFr4rNT) r?_schemar6rRrL after_setnextiter argumentsrM)rErK alias_setloc first_argargrrrmutates_and_returns_first_args8       rlcCsg}i}tt|jD]3}|j|}|jr*|j|vr#||j||j<q |j||j<q |t|kr8|||q ||jq t||fSr)ranger6rg kwarg_onlyr@ default_valueappendtuple)rKrrnew_args new_kwargsiinforrr fill_defaultss    rvr.rccst|jt|t|ksJtt|jD]6}|j|}|jr/|j|vr.|||jfVq|t|krF|jsE|j|vrE|||jfVq|||fVqdS)zzips schema.arguments and (args, kwargs) together. Assumes that (args, kwargs) were the inputs to some torch._ops.OpOverload: that is, (args, kwargs) must be bindable to the schema (args, kwargs). N)r6rgrmrnr@)rKrrrtrurrr zip_schemas   rwcsddlm}|j}t|tjjstdddg}|jD]6}t|tj j tj j j fr3| |qt|tj j jttfrK| fdd|Dqtdt|t|jj|}|}||jt|jt|fS) Nr)FunctionSchemaGenzfx_node's target must be a hop.cSs8|jdd}|dur|jdksJt|jj|j}|S)Nvalget_attr)metar^rEr<graph owning_moduletarget)nodemeta_valrrr_collect_example_vals z5hop_schema_from_fx_node.._collect_example_valcsg|]}|qSrr)rNxrrr sz+hop_schema_from_fx_node..zUnsupported arg type )torchgen.gen_schema_utilsrxr~rIr=_opsHigherOrderOperator RuntimeErrorrfxNoderrpimmutable_collectionsimmutable_listlistrqtyper* signaturerbind from_example_namergitems)rrxhopexample_inputsrk bound_argsexample_outputrrrhop_schema_from_fx_nodes*   rcCs@t|tsJt|r dS|j}|jsdSt|jdkrdSdS)NFrT)rIr rJrcrQr6rR)rErKrrrcan_generate_trivial_fake_implsrcCs ttddS)zIf an op was defined in C++ and extended from Python using the torch.library APIs, returns if we require that there have been a m.set_python_module("mylib.ops") call from C++ that associates the C++ op with a python module. REQUIRES_SET_PYTHON_MODULET)r<rrrrrrequires_set_python_modules rcOsLt|tjjjs Jtjj||f\}}dd|D}|||||S)NcSs8g|]}t|tjrtj|tjjjrt|qSr) rIr=Tensorr_dispatch_keyshas DispatchKeyPythonrrNarrrr s z(handle_dispatch_mode..) rIr=utils_python_dispatchTorchDispatchMode_pytree tree_flattenvalues__torch_dispatch__) curr_mode op_overloadrrargs_flattened_overload_typesrrrhandle_dispatch_modes rcCtdd|jDS)Ncss|]}|jVqdSr)rnrrrrrP,sz&has_kwarg_only_args..rSrgrKrrrhas_kwarg_only_args+srcCs2|jD]}t|jst|jsq|jsqdSdS)NTF)rgrbrrarn)rKrrrrhas_kwarg_only_tensors/s rcCr)z Given a schema, returns True if the schema has a Tensor arg. A Tensor arg is any arg with a type annotation that might involve Tensor. css$|] }t|jp t|jVqdSr)rbrrarrrrrP>s  z!has_tensor_arg..rrrrrhas_tensor_arg9srcCs:t|jD]\}}|jtjur|jdkr|SqdS)zx Given a schema, returns the id of the `device: torch.device` argument. If it does not exist, returns None. deviceN) enumeratergrr DeviceObjTyper^r@)rKindexrkrrrget_device_arg_indexDs rr4allowed_nestingc#sFfdd}|D] }||EdHq |D] }||EdHqdS)Nc3sTt|tjr |VdSdkr&t|ttfr(tt|idEdHdSdSdS)Nrr4)rIr=rrqr iter_tensors)rkrrrcheckRs   ziter_tensors..check)r)rrrrrkkwargrrrrOs  rcCsdS)Nz???rrrrr^srcCsrdd|D}|}t|ts|f}t|iD] }t|}t||vr1t|d|d||qdS)zO custom operators' outputs must not alias any inputs or other outputs. cSs$h|]}t|tjrt|qSr)rIr=riduntyped_storage)rNtrrr bs$z,check_aliasing_constraint..z (with implementation in a): The output of this custom operator (1) must not also be an input to this custom operator and (2) may not alias any inputs to this custom operator or other returns. The most common way to trigger this error is if we have y = custom_op(x) and y and x are the same Tensor. Please instead return a clone of the offending output tensor(s) (e.g. return x.clone()) or refactor the custom operator to not return y.N)rIrqrrrradd)r@prevresult get_modulestorages tuple_resulttensorkeyrrrcheck_aliasing_constraint^s   rc@s eZdZdZddZddZdS)MutationCheckerz Check if an operator mutated its arguments. Usage: checker = MutationChecker(op, flat_args, args_spec) op(*args, **kwargs) checker.check() cCs&||_||_||_dd|D|_dS)NcS$g|]}t|tjrt|ndqSrrIr=r hash_tensorrrrrrsz,MutationChecker.__init__..)rE args_spec flat_argsreal_pre_hashes)rrErrrrrr%s  zMutationChecker.__init__csddjD}ddtj|D}t|j\}}tjj||D])\}}fdd}t |j r9|||q$t |j rM|durDdnt |}|||q$dS)NcSrrrrrrrrsz)MutationChecker.check..cSsTg|]&\}}t|tjr&t|tjr&t|| o%|o$| ndqSr)rIr=requalisnanall)rNprepostrrrrs  c sB|j|krdStjjd|jdjjd|jrdndd)Nz: for argument 'z': the operator's schema z specified that the operator mutateszdoes not mutatea* the argument, but this seems to be emperically wrong. Please make the schema and operator behavior consistent. You can specify that an operator mutates a Tensor by e.g. changing its schema type from 'Tensor name' to 'Tensor(a!) name'(use different identifiers (a, b, c, ...) for different Tensors))rMrrErr@rc)ru was_mutatedr'rr check_ones  z(MutationChecker.check..check_oneF) rziprpytreetree_unflattenrrwrErcrbrrarS)rreal_post_hashesrwas_mutated_argswas_mutated_kwargsrurwas_any_mutatedrr'rrs(       zMutationChecker.checkN)rrrrr%rrrrrrxs rrcCs|S)zNSome inexpensive hash. Used as a quick and dirty indicator for tensor mutation)detachfloatmean)rrrrrsrcCst|rdS|j}tj|drdStjj|}|durAtj|dr&dStjjj |}|j j dur6dStj|dr?dSdS|j durHdSdS)zIf an operator (that stays alive until FakeTensorMode) has a Fake kernel. Don't use this if the operator decomposes before FakeTensorMode. TCompositeImplicitAutogradNCompositeExplicitAutogradMetaF)rrr=r%_dispatch_has_kernel_for_dispatch_key_library custom_ops_maybe_get_opdefsimple_registry singletonfind fake_implkernel _abstract_fn)rEr@opdefentryrrrhas_fake_kernels,  rcCsTg}g}t|jD]\}}|jdur%|jjr%|jr ||jq ||q ||fSr)rrgrLrMrnrpr@)rKidxskeysrtrurrrmutated_args_kwargss r)r )r4): dataclassesr*r,r collections.abcrrtypingrrrr=torch.utils._pytreerrrrr torch._opsr r dataclassrr!intr r1rqr9rDboolrJrZrarbrlrvrWdictArgumentrwrrrrrrrrrrrrrrrrrrrrrsn       # &   &      :(