a 7Sic;*@sddlZddlZddlZddlZddlZddlZddlZeedoJeedZ ej ddZ GdddZ Gdd d Z Gd d d ejZGd d d ejZeZdS)Ngetdlopenflagssetdlopenflagsccs4trt}t|tjBdVtr0t|dS)z Context manager to set the RTLD_GLOBAL dynamic linker flag while we open a shared library to load custom operators. N)_SET_GLOBAL_FLAGSsysrrctypes RTLD_GLOBAL) old_flagsr F/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/_ops.py dl_open_guards r c@s^eZdZddZdddZddZdd Zd d Zd d ZddZ e ddZ e ddZ dS) OpOverloadcCsZ||_||_||_|jdkr dn|j|_d|jjdd|j|_|j |_ |j |_ dS)Ndefault{}.{}::) _op_schema_overloadpacket overload_name _overloadnameformatnamesplit__name__ __module__)selfoverloadpacketopschemar r r __init__szOpOverload.__init__NcCs|SNr rmemor r r __deepcopy__)szOpOverload.__deepcopy__cCs djg|jjd|jRS)Nz'rrrrrrrr r r __repr__,szOpOverload.__repr__cOs|j|i|piSr!rrargskwargsr r r __call__/szOpOverload.__call__cCs t|j|Sr!)getattrr)rkeyr r r __getattr__2szOpOverload.__getattr__cCs t|jSr!hashrr&r r r __hash__5szOpOverload.__hash__cCs djg|jjd|jRS)Nz{}.{}.{}rr%r&r r r __str__9szOpOverload.__str__cCs|jSr!)rr&r r r r<szOpOverload.overloadpacketcCs|jSr!r(r&r r r r@sz OpOverload.op)N) rr __qualname__r r$r'r,r/r2r3propertyrrr r r r r s  r c@sZeZdZddZdddZddZdd Zd d Zed d Z ddZ ddZ ddZ dS)OpOverloadPacketcCs||_||_||_||_dSr!)_qualified_op_namerr_overload_names)rqualified_op_nameop_nameroverload_namesr r r r IszOpOverloadPacket.__init__NcCs|Sr!r r"r r r r$RszOpOverloadPacket.__deepcopy__cCsdj|jdS)Nzrrr7rr&r r r r'UszOpOverloadPacket.__repr__cCs t|jSr!r0r&r r r r2XszOpOverloadPacket.__hash__cCsdj|jdS)Nrrr<r&r r r r3[szOpOverloadPacket.__str__cCs|jSr!r(r&r r r r^szOpOverloadPacket.opc Cs|dkr dSz|dr&t|j|WSWn0tyXtdt|t|j|dYn0zN|dkrhdn|}tj|j |}tj |j |}t |||}t ||||WSt ytdt||dYn0dS)N__file__ torch.ops__zi'{}' can't have an overload name beginning with '__' and the underlying op {} has no attribute {} either.rr z3The underlying op of '{}' has no overload name '{}') startswithr-rAttributeErrorrstrtorch_C_get_operation_overloadr7 _get_schemar setattr RuntimeError)rr.use_keyop_roverloadr r r r/bs4      zOpOverloadPacket.__getattr__cOs|j|i|piSr!r(r)r r r r,szOpOverloadPacket.__call__cCsdd|jDS)NcSsg|]}|r|ndqS)rr ).0nr r r z.OpOverloadPacket.overloads..)r8r&r r r overloadsszOpOverloadPacket.overloads)N) rrr4r r$r'r2r3r5rr/r,rPr r r r r6Hs  (r6cs(eZdZdZfddZddZZS) _OpNamespacea0 An op namespace to dynamically bind Operators into Python. Say a user has created a custom Operator called "my_namespace::my_op". To call this op, the user will write torch.ops.my_namespace.my_op(...). At startup, this operation will not yet be bound into Python. Instead, the following sequence of magic tricks will occur: 1. `torch.ops.my_namespace` will invoke the `__getattr__` magic method on the `torch.ops` object, which will create a new `_OpNamespace` object called `my_namespace` and set it as an attribute on the `ops` object. 2. `torch.ops.my_namespace.my_op` will then invoke `__getattr__` on the `my_namespace` object, which will retrieve the operation via `torch.get_operation`, a function bound from C++, and then in a similar fashion bind this new object onto the `my_namespace` object. 3. `torch.ops.my_namespace.my_op(...)` then calls this new operation and subsequent accesses will incur no further lookup (the namespace and operation will already exist). cstt|d|||_dS)Nz torch.ops.)superrQr r)rr __class__r r r sz_OpNamespace.__init__c Cs|dkr dS|j}d||}ztj|\}}Wn6tyh}ztd|d|WYd}~n d}~00tjj |||j d||_ t ||||}|j d||_ t ||||S)Nr=r>z{}::{}z('_OpNamespace' object has no attribute ''.) rrrCrD_jit_get_operationrHrAjit _builtins_register_builtinrr6rG)rr:Znamespace_namer9rr;eZopoverloadpacketr r r r/s ( z_OpNamespace.__getattr__)rrr4__doc__r r/ __classcell__r r rSr rQs rQcs0eZdZdZfddZddZddZZS)_Opsz_ops.pycstt|dt|_dS)Nr>)rRr^r setloaded_librariesr&rSr r r sz _Ops.__init__cCst|}t||||Sr!)rQrG)rr namespacer r r r/s z_Ops.__getattr__cCsZtjdkrdStj|}tt|Wdn1s@0Y|j |dS)a  Loads a shared library from the given path into the current process. The library being loaded may run global initialization code to register custom operators with the PyTorch JIT runtime. This allows dynamically loading custom operators. For this, you should compile your operator and the static registration code into a shared library object, and then call ``torch.ops.load_library('path/to/libcustom.so')`` to load the shared object. After the library is loaded, it is added to the ``torch.ops.loaded_libraries`` attribute, a set that may be inspected for the paths of all libraries loaded using this function. Args: path (str): A path to a shared library to load. torch_deployN) r executablerC_utils_internalresolve_library_pathr rCDLLr`add)rpathr r r load_librarys   (z_Ops.load_library)rrr4r=r r/rir]r r rSr r^s r^)torch._CrC contextlibrrtypes torch.jitZtorch._utils_internalhasattrrcontextmanagerr r r6 ModuleTyperQr^opsr r r r s *\4,