a 7SicI@s>ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZddlmZddlmZddlmZddlmZdd lmZmZmZmZmZmZmZm Z m!Z!ddl"Z"ddl#Z#ddl$Z$d Z%e&d j'Z(e&d j'Z)e&d j'Z*dZ+dZ,dZ-Gddde.Z/e ddZ0gZ1e2dddZ3ddZ4diddZ5ddZ6dd Z7d!d"Z8d#d$Z9d%d&Z:e4d'e6e8e4d(e7e:e eej;jd,d-Z?d.d/Z@d0d1ZAd2d3ZBGd4d5d5eCZDGd6d7d7eDZEGd8d9d9eDZFGd:d;d;eDZGdd?d?eDZIGd@dAdAeDZJGdBdCdCeDZKdDdEZLe2ddFdGZMdHdIZNe2ddJdKZOdddLdMZPe#e%dfe eQejRee!eSfddNdOdPZTdddQdRZUdSdTZVde#fdUdVZWdWdXZXieX_Ye"#ejZdYdZd[d\Z[e eSeQfeQd]d^d_Z\d`daZ]GdbdcdcZ^djdedfZ_dgdhZ`dS)kN)closingcontextmanager)_import_dotted_name)string_classes)get_source_lines_and_file)Storage)#_get_dtype_from_pickle_storage_type) AnyBinaryIOcastDictOptionalTypeTupleUnionIOz=lz=iz=hll|9 QC i,c@s eZdZdS)SourceChangeWarningN)__name__ __module__ __qualname__rrO/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/serialization.pyr srccst}|Vt|dSN)tempfilemkdtempshutilrmtreepathrrrr$srreturncCs\g}|}|d}|dkrB||t|dkr6qB|d}q||gd}||kS)Nr)PK)tellreadappendlenseek)f read_bytesstartbyteZlocal_header_magic_numberrrr _is_zipfile.s      r3cCs |||f}t|tdSr)_package_registryr,sort)prioritytaggerZ deserializerZ queue_elemrrrregister_packageFs  r8Tc sz2|jdtfddt|D}||k}Wn\ty}zDd|j|jt|f}|rht||nt |dd}WYd}~n d}~00|S)a Check if a module's version satisfies requirements Usually, a module's version string will be like 'x.y.z', which would be represented as a tuple (x, y, z), but sometimes it could be an unexpected format. If the version string does not match the given tuple's format up to the length of the tuple, then error and exit or emit a warning. Args: module: the module to check the version of req_version_tuple: tuple (usually of ints) representing the required version error_if_malformed: whether we should exit if module version string is malformed Returns: requirement_is_met: bool .c3s"|]\}}t||VqdSr)type).0idxZ req_fieldZ version_strsrr `sz8check_module_version_greater_or_equal..zQ'%s' module version string is malformed '%s' and cannot be compared with tuple %sz1, but continuing assuming that requirement is metTN) __version__splittuple enumerate Exceptionrstr RuntimeErrorwarningswarn)moduleZreq_version_tupleZerror_if_malformedZmodule_versionZrequirement_is_metemessagerr=r%check_module_version_greater_or_equalLs     rKcCs|jjdkrdSdSNcpu)devicer:objrrr_cpu_tagus rQcCs |jjdkrdt|jjSdS)Ncudazcuda:)rNr:rDindexrOrrr _cuda_tagzs rTcCs|dkr |SdSrLr)rPlocationrrr_cpu_deserializesrVcCsNtjj|d}tjs"tdtj}||krJtd|d|d|S)NTzAttempting to deserialize object on a CUDA device but torch.cuda.is_available() is False. If you are running on a CPU-only machine, please use torch.load with map_location=torch.device('cpu') to map your storages to the CPU.z0Attempting to deserialize object on CUDA device z" but torch.cuda.device_count() is zU. Please use torch.load with map_location to map your storages to an existing device.)torchrR_utils_get_device_index is_availablerE device_count)rUrNr[rrrvalidate_cuda_devices   r\cCsr|drnt|}t|ddrdtj|(tj|t|dWdS1sX0Yn ||SdS)NrR_torch_load_uninitializedF)rN) startswithr\getattrrWrRrN_UntypedStoragenbytes)rPrUrNrrr_cuda_deserializes   8rb )storagecCs:tD]\}}}||}|r|Sqtdt|dS)Nz-don't know how to determine data location of r4rErWtypename)re_r7rUrrr location_tags ricCsLtD]$\}}}|||}|dur|Sqtdt|d|ddS)Nz+don't know how to restore data location of z (tagged with )rf)rerUrhfnresultrrrdefault_restore_locations  rmcCs tt|jSr)r_rWr) storage_typerrrnormalize_storage_typesrocCs&t|}t|j}t||jddS)NrTensor)r:rrr_rreplace)rernrHrrrstorage_to_tensor_types rrcCst|tpt|tjSr) isinstancerDpathlibPath)name_or_bufferrrr_is_paths  rwc@s$eZdZddZddZddZdS)_openercCs ||_dSr file_like)selfrzrrr__init__sz_opener.__init__cCs|jSrryr{rrr __enter__sz_opener.__enter__cGsdSrrr{argsrrr__exit__sz_opener.__exit__N)rrrr|r~rrrrrrxsrxcs$eZdZfddZddZZS) _open_filecstt|t||dSr)superrr|open)r{namemode __class__rrr|sz_open_file.__init__cGs|jdSr)rzcloserrrrrsz_open_file.__exit__rrrr|r __classcell__rrrrrs rcseZdZfddZZS)_open_buffer_readercstt||t|dSr)rrr|_check_seekabler{bufferrrrr|sz_open_buffer_reader.__init__rrrr|rrrrrrsrc@seZdZddZdS)_open_buffer_writercGs|jdSr)rzflushrrrrrsz_open_buffer_writer.__exit__N)rrrrrrrrrsrcCsDt|rt||Sd|vr"t|Sd|vr2t|Std|dS)Nwrz$Expected 'r' or 'w' in mode but got )rwrrrrE)rvrrrr_open_file_likes rcs"eZdZddfdd ZZS)_open_zipfile_readerNr"cstt|tj|dSr)rrr|rW_CPyTorchFileReader)r{rvrrrr|sz_open_zipfile_reader.__init__rrrrrrsrcs0eZdZddfdd ZddddZZS)_open_zipfile_writer_fileNr"cs tt|tjt|dSr)rrr|rWrPyTorchFileWriterrDr{rrrrr|sz"_open_zipfile_writer_file.__init__cGs|jdSr)rzwrite_end_of_filerrrrrsz"_open_zipfile_writer_file.__exit__rrrrrrsrcs0eZdZddfdd ZddddZZS)_open_zipfile_writer_bufferNr"cs"||_tt|tj|dSr)rrrr|rWrrrrrrr|sz$_open_zipfile_writer_buffer.__init__cGs|j|jdSr)rzrrrrrrrrs z$_open_zipfile_writer_buffer.__exit__rrrrrrsrcCst|rt}nt}||Sr)rwrr)rv containerrrr_open_zipfile_writersrcCs,dg}z |j|vWSty&YdS0dS)NgzipF)rAttributeError)r/Zcompress_modulesrrr_is_compressed_files   rcCsHt|r dSz|dkWStjy0YdStyBYdS0dS)z Checks if f is a file that should be read directly. It should be read directly if it is backed by a real file (has a fileno) and is not a a compressed file (e.g. gzip) FrN)rfilenoioUnsupportedOperationr)r/rrr_should_read_directlys rc CsZdd}z||WdStjtfyT}z|ddg|WYd}~n d}~00dS)NcSs>|D]0}|t|vrt|ddd}t||q|dS)Nz7. You can only torch.load from a file that is seekable.z; Please pre-load the data into a buffer like io.BytesIO andz try to load from it instead.)rDr:)patternsrIpmsgrrr raise_err_msg*s  z&_check_seekable..raise_err_msgTr.r*F)r.r*rrr)r/rrIrrrr(s $rcCs@|jdkr= %s, but you have dill %s. Please upgrade dill or switch to 'pickle'r9cSsg|] }t|qSr)rD)r;numrrr Iz'_check_dill_version..N)rrK ValueErrorjoinr?) pickle_moduleZrequired_dill_versionrrr_check_dill_version:s  r)r/r#c Cst|t|df}|r\t|,}t||||WdWddS1sR0Yt||||Wdn1s~0YdS)asave(obj, f, pickle_module=pickle, pickle_protocol=DEFAULT_PROTOCOL, _use_new_zipfile_serialization=True) Saves an object to a disk file. See also: :ref:`saving-loading-tensors` Args: obj: saved object f: a file-like object (has to implement write and flush) or a string or os.PathLike object containing a file name pickle_module: module used for pickling metadata and objects pickle_protocol: can be specified to override the default protocol .. note:: A common PyTorch convention is to save tensors using .pt file extension. .. note:: PyTorch preserves storage sharing across serialization. See :ref:`preserve-storage-sharing` for more details. .. note:: The 1.6 release of PyTorch switched ``torch.save`` to use a new zipfile-based file format. ``torch.load`` still retains the ability to load files in the old format. If for any reason you want ``torch.save`` to use the old format, pass the kwarg ``_use_new_zipfile_serialization=False``. Example: >>> # Save to file >>> x = torch.tensor([0, 1, 2, 3, 4]) >>> torch.save(x, 'tensor.pt') >>> # Save to io.BytesIO buffer >>> buffer = io.BytesIO() >>> torch.save(x, buffer) wbN)rrr_save _legacy_save)rPr/rpickle_protocol_use_new_zipfile_serialization opened_fileopened_zipfilerrrsaveMs)  ,rc sddlmiiitttdfdd }tttjdktt t t dd}|j t ||d|j t||d|j |||d|j||d}||_| |t}|j |||d||D],}|\} } | |t|d tj| qdS) Nr)rPr#cst|trt|jr|vr"dSd|<d}}zt|\}}}d|}Wn&tyttd|j dYn0d|||fSt|t j j st |rt|t j j r|j}|j}|}tt |}|j} |} nFt|t jr |}t j}tt|}t j} |} ntdt||dkrb|vrV||krbtdn ||<d} t|j} t|} | vr|| f| <|j|jk}|rt|j| |f}nd}d || | | |f}|SdS) NTr$4Couldn't retrieve source code for container of type 3. It won't be checked for correctness upon loading.rHztype not recognized: rSCannot save multiple tensors or storages that view the same data as different typesre)rsr: issubclassModulerrrCrFrGrrWre _TypedStorage is_storage_storagedtypepickle_storage_typer_sizer`uint8rora TypeErrordata_ptrrErD_cdatari)rP source_filesource source_linesrhre storage_dtypestorage_type_strrnr storage_numeloffset storage_keyrUZis_view view_metadataresnnZserialized_container_typesserialized_storagesstorage_dtypesrr persistent_idsn            z#_legacy_save..persistent_idlittle)shortintlong)protocol_version little_endianZ type_sizesprotocolT)Ztorch.nnrr rrdictPROTOCOL_VERSIONsys byteorder SHORT_SIZEINT_SIZE LONG_SIZEdump MAGIC_NUMBERPicklerrsortedkeysr _write_filerrWrX _element_size) rPr/rrrZsys_infopicklerZserialized_storage_keyskeyrerrrrrs4 l    rc siiifdd}t}|j||d}||_|||}|d|t|t D]D}d|} |} | j j dkr| } | } || | | qhdS)Ncst|tjjst|rt|tjjrN|j}|j}|}tt|}| }n|}tj }t t |}| }|dkr|vr||krtdn ||<|jtt}t|}||<d||||fSdS)Nrrre)rsrWrerrrrrr_rrror:rarrE setdefaultrrDr-ri)rPrerrrnrrrUZid_maprrrrrs8      z_save..persistent_idrdata.pkldata/rM)rBytesIOrrrgetvalue write_recordr-rrrNr:rMrar) rPzip_filerrrZdata_bufr data_valuerrre num_bytesrrrrs"0   rc Kst|d|vrd|d<t|d}t|r|}t|x}t|rtdt | |t j |WdWdSt|||fi|WdWdS1s0Yt|||fi|WdS1s0YdS)a}load(f, map_location=None, pickle_module=pickle, **pickle_load_args) Loads an object saved with :func:`torch.save` from a file. :func:`torch.load` uses Python's unpickling facilities but treats storages, which underlie tensors, specially. They are first deserialized on the CPU and are then moved to the device they were saved from. If this fails (e.g. because the run time system doesn't have certain devices), an exception is raised. However, storages can be dynamically remapped to an alternative set of devices using the :attr:`map_location` argument. If :attr:`map_location` is a callable, it will be called once for each serialized storage with two arguments: storage and location. The storage argument will be the initial deserialization of the storage, residing on the CPU. Each serialized storage has a location tag associated with it which identifies the device it was saved from, and this tag is the second argument passed to :attr:`map_location`. The builtin location tags are ``'cpu'`` for CPU tensors and ``'cuda:device_id'`` (e.g. ``'cuda:2'``) for CUDA tensors. :attr:`map_location` should return either ``None`` or a storage. If :attr:`map_location` returns a storage, it will be used as the final deserialized object, already moved to the right device. Otherwise, :func:`torch.load` will fall back to the default behavior, as if :attr:`map_location` wasn't specified. If :attr:`map_location` is a :class:`torch.device` object or a string containing a device tag, it indicates the location where all tensors should be loaded. Otherwise, if :attr:`map_location` is a dict, it will be used to remap location tags appearing in the file (keys), to ones that specify where to put the storages (values). User extensions can register their own location tags and tagging and deserialization methods using :func:`torch.serialization.register_package`. Args: f: a file-like object (has to implement :meth:`read`, :meth:`readline`, :meth:`tell`, and :meth:`seek`), or a string or os.PathLike object containing a file name map_location: a function, :class:`torch.device`, string or a dict specifying how to remap storage locations pickle_module: module used for unpickling metadata and objects (has to match the :attr:`pickle_module` used to serialize file) pickle_load_args: (Python 3 only) optional keyword arguments passed over to :func:`pickle_module.load` and :func:`pickle_module.Unpickler`, e.g., :attr:`errors=...`. .. warning:: :func:`torch.load()` uses ``pickle`` module implicitly, which is known to be insecure. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling. Never load data that could have come from an untrusted source, or that could have been tampered with. **Only load data you trust**. .. note:: When you call :func:`torch.load()` on a file which contains GPU tensors, those tensors will be loaded to GPU by default. You can call ``torch.load(.., map_location='cpu')`` and then :meth:`load_state_dict` to avoid GPU RAM surge when loading a model checkpoint. .. note:: By default, we decode byte strings as ``utf-8``. This is to avoid a common error case ``UnicodeDecodeError: 'ascii' codec can't decode byte 0x...`` when loading files saved by Python 2 in Python 3. If this default is incorrect, you may use an extra :attr:`encoding` keyword argument to specify how these objects should be loaded, e.g., :attr:`encoding='latin1'` decodes them to strings using ``latin1`` encoding, and :attr:`encoding='bytes'` keeps them as byte arrays which can be decoded later with ``byte_array.decode(...)``. Example: >>> torch.load('tensors.pt') # Load all tensors onto the CPU >>> torch.load('tensors.pt', map_location=torch.device('cpu')) # Load all tensors onto the CPU, using a function >>> torch.load('tensors.pt', map_location=lambda storage, loc: storage) # Load all tensors onto GPU 1 >>> torch.load('tensors.pt', map_location=lambda storage, loc: storage.cuda(1)) # Map tensors from GPU 1 to GPU 0 >>> torch.load('tensors.pt', map_location={'cuda:1':'cuda:0'}) # Load tensor from io.BytesIO object >>> with open('tensor.pt', 'rb') as f: ... buffer = io.BytesIO(f.read()) >>> torch.load(buffer) # Load a module with 'ascii' encoding for unpickling >>> torch.load('module.pt', encoding='ascii') encodingzutf-8rbz'torch.load' received a zip file that looks like a TorchScript archive dispatching to 'torch.jit.load' (call 'torch.jit.load' directly to silence this warning)N)rrrr3r*r_is_torchscript_ziprFrG UserWarningr.rWjitload_load _legacy_load)r/ map_locationrpickle_load_argsrZ orig_positionrrrrr_sW    (@rcCs:tj}|s2tjD]}t|tjr||t|<q||S)z@Get layout extension object from its string representation. ) _get_layoutcacherW__dict__valuesrslayoutrD)rrvrrrrs  rcCstt|ffSr)rrDrOrrrrr c sit|Gdddjddfdd}ifdd}t|t|}|r|d krz ||WStjyt|rt|j d d| d Yn0t |d sd t j krd krnntdt|dj|fi}|tkrtdj|fi}|tkr6td|j|fi} |fi} || _| } j|fi} |r|nd} | D]J}|vsJ|}|j|| |tj|j| dur|} qtj| S)NcseZdZfddZZS)z&_legacy_load..UnpicklerWrappercs@t|tur2d|vr2z t|WSty0Yn0t||SNr)r:rD StorageTypeKeyErrorr find_classr{mod_namerrrrrs   z1_legacy_load..UnpicklerWrapper.find_classrrrrrrrrrUnpicklerWrappersrc Ss\zdt|d}Wn(ty>td|jdYdS0||krX|jr2|jd}tj| d| d||dd}d|}zt |dV}| dd }| d|dkr| |n|t |ks||krtWdn1s0Yd |d |d } Wn ty.d |d} Yn0nd} dt|d| } t| tdS)Nr$rrrz.patch )linetermza+rzSaved a reverse patch to z. Run `patch -p0 < z` to revert your changes.z;Tried to save a patch, but couldn't create a writable file zD. Make sure it doesn't exist and your working directory is writable.zyou can retrieve the original source code by accessing the object's source attribute or set `torch.nn.Module.dump_patches = True` and use the patch tool to revert the changes.zsource code of class 'z' has changed. )rrrCrFrGrZ dump_patchesdifflib unified_diffr@rr.writer-r+IOErrorrWrgr) Zcontainer_typerZoriginal_sourceZcurrent_source file_namedifflinesr/ file_sizerrrr_check_container_sourcesP         "  z-_legacy_load.._check_container_sourcec sifdd}ttj|dtjd}t}|jd|dttj|ddd}j |fi}t |D]`}j |fi}|\}}} | j } t t tj|tj| } | |} tjj| | d |<qvj |fi} | D]R\} }}}|}tj|j }||}tjj|j|||||j d | <qWdn1sX0Y|jd |dttj|d dd}j |fi}t |D]}j |fi}|\}}}|}td |d \}|d td |d|d|}td |d|d|}td|d\}tjg|j d|j|||}||<qWdn1sx0Y|d}|fi}||_| }|WdWdS1s0YWdn1s0YdS)Ncs6t|tr*t|ddr"||dSt|S)Nrr)rsrAallr)saved_id)rdeserialized_objectsrrpersistent_loads  z:_legacy_load..legacy_load..persistent_loadzr:)fileobjrformatstoragesr rr wrap_storagertensorsz.legacy_loadcsJt|tsJt|d}|dd}|dkrNt|ddrF||dS|dkr6|\}}}}}t|}|j}|tj|} |vrtt t | } d| _ tj j | ||d|<|} |dur.|\} } }| tj|}|tj|}| vr$tj j | j||||d| <| }n| }|Std|ddS)NrrrHreTr&zUnknown saved id type: %s)rsrA_maybe_decode_asciirrrWrXrr rr`r]rerrrE)r rgdatarnZroot_keyrUr9rrrarP typed_storageZview_keyrZ view_sizer<Zview_size_bytesr)rr!rBrrr"UsB         z%_legacy_load..persistent_loadrz9 is a zip archive (did you mean to use torch.jit.load()?)readinto)rr+r)rr+rztorch.load does not work with file-like objects that do not implement readinto on Python 3.8.0 and 3.8.1. Received object of type "zH". Please update to Python 3.8.2 or newer to restore this functionality.z#Invalid magic number; corrupt file?zInvalid protocol version: %s)_get_restore_location Unpicklerrrr*r.TarErrorr3rErr.hasattrr version_infor:rrrr"r_set_from_filerWrXrr_validate_loaded_sparse_tensors)r/rrrrCr"Zf_should_read_directlyZ magic_numberrZ _sys_inforArlZdeserialized_storage_keysrrrFr)rrr!rrrBrrsb (?-  $       r) bytes_strr#cCst|tr|dS|S)Nascii)rsbytesdecode)rOrrrrDs  rDcshdurt}nVttr&fdd}n>ttr>fdd}n&ttjrXfdd}n fdd}|S)Ncs||}t||Sr)getrmrerUrrrrBs z/_get_restore_location..restore_locationcs t|SrrmrTrUrrrBscst|tSr)rmrDrTrUrrrBscs ||}|durt||}|SrrV)rerUrlrUrrrBs  )rmrsr_string_classesrWrN)rrBrrUrrHs    rHc@seZdZddZddZdS)r cCst||_dSr)r rrrrrr|szStorageType.__init__cCsd|jdS)NzStorageType(dtype=rjr,r}rrr__str__szStorageType.__str__N)rrrr|rXrrrrr sr rc  st|ifddfdd}ddiGfddd|j}t|}||fi|}||_|} tj | S) Ncs@d|}||tj}tjj|||d|<dS)Nrr&)get_storage_from_recordrWr`re_untypedr)rr9rrUrre)loaded_storagesrBrrr load_tensors  z_load..load_tensorc st|tsJt|d}|dd}|dks>Jd|d|\}}}}|tjur\tj}n|j}|vr|tj|}|||t||S)NrrrezBUnknown typename for persistent_load, expected 'storage' but got '') rsrArDrWr`rrrXr) r rgrErnrrUr9rra)r\r[rrr"s      z_load..persistent_loadz torch.tensorz torch._tensorcseZdZfddZZS)z_load..UnpicklerWrappercsLt|tur2d|vr2z t|WSty0Yn0||}t||Sr )r:rDr rrSrrr)rload_module_mappingrrr s   z*_load..UnpicklerWrapper.find_classrr)r^rrrsr) rHrIrr get_recordr"rrWrXrN) rrrr@rr"rZ data_filerArlr)r^r\r[rBrrrs  rcCs d|vS)Nz constants.pkl)get_all_records)rrrrr sr)T)r)arr0rrr3rrWr.rrF contextlibrrrXr_sixrrWZtorch._sourcesr torch.typesrZ torch.storager typingr r r r rrrrrcopyregr-rtDEFAULT_PROTOCOLStructrrrrrrZSTORAGE_KEY_SEPARATORWarningrrr4boolr3r8rKrQrTrVr\rbrerr`rirmrorrrwobjectrxrrrrrrrrrrrrrDPathLikerQrrrrrrr rrDrHr rrrrrrs     ,     )         3Oo Y  C