U dϾ@sddlZddlZddlZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZddlZddlmZmZddl m!Z!dd l"m#Z#d d l$m%Z%d d l&m'Z'd d l(m)Z)m*Z*d dl+m,Z,d dl-m.Z.d dl/m0Z0d dl1m2Z2m3Z3d dl4m5Z5m6Z6m7Z7dZ8ede9gdfZ:Gddde Z;Gddde ZZ?Gddde>Z@GdddZAd d!gZBd"ZCe9e9d#d$d%ZDdS)&N) OrderedDict defaultdict) dataclass)Enum)Path) AnyBinaryIOCallableDictListOptionalSequenceSetUnioncast DefaultDict) location_tagnormalize_storage_type)Storage)RemovableHandle)DiGraph)_normalize_path)demangle is_mangled)create_pickler)is_stdlib_module)find_files_source_depends_on) GlobGroup GlobPattern)ImporterOrderedImporter sys_importerTPackageExporterc@s(eZdZdZdZdZdZdZdZdZ dS) _ModuleProviderActionzRepresents one of the actions that :class:`PackageExporter` can take on a module. See :meth:`PackageExporter.extern` and friends for a description of what the actions do. rN) __name__ __module__ __qualname____doc__INTERNEXTERNMOCKDENYREPACKAGED_MOCK_MODULESKIPr4r4B/tmp/pip-unpacked-wheel-ua33x9lu/torch/package/package_exporter.pyr$-sr$c@s4eZdZdZddZdZdZdZdZdZ d Z d Z d S) PackagingErrorReasonzListing of different reasons a dependency may fail to package. This enum is used to provide good error messages when :class:`PackagingError` is raised. cCsd|jj|jfS)Nz<%s.%s>) __class__r*nameselfr4r4r5__repr__IszPackagingErrorReason.__repr__zKModule is a C extension module. torch.package supports Python modules only.zModule had no __file__ defined.zCModule had a __file__, but we could not find it in your filesystem.zDependency resolution failed.zLModule did not match against any action pattern. Extern, mock, or intern it.zModule was denied by a pattern.zModule was mocked out, but is still being used in the package. Please intern or extern the mocked modules if objects are supposed to be in the package.N) r*r+r,r-r;IS_EXTENSION_MODULENO_DUNDER_FILESOURCE_FILE_NOT_FOUNDDEPENDENCY_RESOLUTION_FAILED NO_ACTIONDENIEDMOCKED_BUT_STILL_USEDr4r4r4r5r6Bsr6c@s2eZdZUdZeed<eed<eed<ddZdS) _PatternInfozQHolds :class:`PackageExporter`-specific info about how to execute matches againstaction allow_empty was_matchedcCs||_||_d|_dS)NF)rDrErF)r:rDrEr4r4r5__init__jsz_PatternInfo.__init__N)r*r+r,r-r$__annotations__boolrGr4r4r4r5rC_s rCc@seZdZdZdS)EmptyMatchErrorzThis is an exception that is thrown when a mock or extern is marked as ``allow_empty=False``, and is not matched with any module during packaging. N)r*r+r,r-r4r4r4r5rJpsrJcs&eZdZdZedfdd ZZS)PackagingErrorzThis exception is raised when there is an issue with exporting a package. ``PackageExporter`` will attempt to gather up all the errors and present them to you at once. )dependency_graphc stt}|jD]@\}}|d}|dkr.q|tjkrDd|ksDt|||qt }| d|D]b\}}| d|j d|D]@}| d|d|j|d} | dk r| d| dqqn||_ t|dS)NerrorrD z* z error_contextz Context: )rlistnodesitemsgetr6r@AssertionErrorappendioStringIOwritevaluerLsuperrGgetvalue) r:rLbroken module_nameattrsrMmessagereasonZ module_namesrOr7r4r5rG~s&    zPackagingError.__init__)r*r+r,r-rrG __classcell__r4r4rar5rKxsrKc@seZdZUdZeed<efeee e feee efdddZ dqeeddd Z ed d d Zeeeeed ddZdreeeedddZdseeedddZedddZeedddZejeedddZdtedd d!Zduedd"d#Zeed$d%d&Zdveeeeed(d)d*Zeeed+d,d-Z e!d.d/d0Z"e#e$d1d2d3Z%e#e$d1d4d5Z&e#e$d1d6d7Z'd8dd9d:d:ed;dd?Z)d8dd9d:d:ed;d@dAZ*d8dBd:d:dCdDdEZ+dFdGZ,dHdIZ-dJdKZ.dLdMZ/dNdOZ0dPdQZ1dRdSZ2dTdUZ3dVdWZ4dXdYZ5dZd[Z6edd\d]Z7ed d^d_Z8ee9eed`dadbZ:eed dcddZ;eed dedfZeeeddkdlZ?eeedmdndoZ@dpS)wr#aExporters allow you to write packages of code, pickled Python data, and arbitrary binary and text resources into a self-contained package. Imports can load this code in a hermetic way, such that code is loaded from the package rather than the normal Python import system. This allows for the packaging of PyTorch model code and data so that it can be run on a server or used in the future for transfer learning. The code contained in packages is copied file-by-file from the original source when it is created, and the file format is a specially organized zip file. Future users of the package can unzip the package, and edit the code in order to perform custom modifications to it. The importer for packages ensures that code in the module can only be loaded from within the package, except for modules explicitly listed as external using :meth:`extern`. The file ``extern_modules`` in the zip archive lists all the modules that a package externally depends on. This prevents "implicit" dependencies where the package runs locally because it is importing a locally-installed package, but then fails when the package is copied to another machine. When source code is added to the package, the exporter can optionally scan it for further code dependencies (``dependencies=True``). It looks for import statements, resolves relative references to qualified module names, and performs an action specified by the user (See: :meth:`extern`, :meth:`mock`, and :meth:`intern`). importer)frccCstjdt|ttfr*t|}d|_n||_tj||_|j dt |_ i|_ t |_tj|j|_|j|_t|_t|_t|_t|tr||_n,t|tjjstdt|dt||_i|_d|_dS)a Create an exporter. Args: f: The location to export to. Can be a ``string``/``Path`` object containing a filename or a binary I/O object. importer: If a single Importer is passed, use that to search for modules. If a sequence of importers are passsed, an ``OrderedImporter`` will be constructed out of them. ztorch.package.PackageExporterNr)zCimporter arg should be an Importer or a sequence of Importers, got z instead.r) torchZ_CZ_log_api_usage_once isinstancerstrbufferZPyTorchFileWriterzip_fileZset_min_versionset_written_filesserialized_reducesrrLZScriptModuleSerializerscript_module_serializerstorage_contextr _extern_hooks _mock_hooks _intern_hooksr rc collectionsabcr TypeErrortyper!patterns _unique_id)r:rdrcr4r4r5rGs0     zPackageExporter.__init__T)r]file_or_directoryc Cst|}|rg}|dd}|dD]}||}|d|} d} |jdkrv| dtd dd} d} n| dtd dd} d } || t t || |fq*|D]} |j | qn|jdk} | |t || |dS) aAdds the local file system ``file_or_directory`` to the source package to provide the code for ``module_name``. Args: module_name (str): e.g. ``"my_package.my_subpackage"``, code will be saved to provide code for this package. file_or_directory (str): the path to a file or directory of code. When a directory, all python files in the directory are recursively copied using :meth:`save_source_file`. If a file is named ``"/__init__.py"`` the code is treated as a package. dependencies (bool, optional): If ``True``, we scan the source for dependencies. ./z**/*.pyNz __init__.py /__init__.pyT.pyF) ris_dirreplaceglob relative_toas_posixr8lenrU _read_filergsave_source_string) r:r]rx dependenciespathZto_save module_pathfilename relative_path archivenameZsubmodule_name is_packageitemr4r4r5save_source_files@       z PackageExporter.save_source_file)returncCst|j}|jd7_|S)zMGet an id. This id is guaranteed to only be handed out once for this package.r)rgrw)r:retr4r4r5 get_unique_id)s zPackageExporter.get_unique_id)srcr]rrc Cs|r|n|jdddd}zt||}WnBtk rj}z$|jj|tjt|dgWYSd}~XYnXi}|D]D\}} | dk r|d| } || rd|| <qt||rtd||<qtt | S)alReturn all modules that this source code depends on. Dependencies are found by scanning the source code for import-like statements. Arguments: src: The Python source code to analyze for dependencies. module_name: The name of the module that ``src`` corresponds to. is_package: Whether this module should be treated as a package. See :py:meth:`save_source_string` for more info. Returns: A list containing modules detected as direct dependencies in ``src``. The items in the list are guaranteed to be unique. ryr)maxsplitr)rMrONT) rsplitr ExceptionrLadd_noder6r?rg_module_existsrPkeys) r:rr]r package_nameZ dep_pairserZdep_module_nameZdep_module_objZpossible_submoduler4r4r5_get_dependencies/s*    z!PackageExporter._get_dependenciesF)r]rrrcCsP|jj|||dtjd|rL||||}|D]}|j||||q.dS)aAdds ``src`` as the source code for ``module_name`` in the exported package. Args: module_name (str): e.g. ``my_package.my_subpackage``, code will be saved to provide code for this package. src (str): The Python source code to save for this package. is_package (bool, optional): If ``True``, this module is treated as a package. Packages are allowed to have submodules (e.g. ``my_package.my_subpackage.my_subsubpackage``), and resources can be saved inside them. Defaults to ``False``. dependencies (bool, optional): If ``True``, we scan the source for dependencies. T)sourcerprovidedrDN)rLrr$r.radd_edgeadd_dependency)r:r]rrrdepsdepr4r4r5r`sz"PackageExporter.save_source_string)r]rrcCs,|rdnd}|dd|}|||dS)zWrite ``src`` as the source code for ``module_name`` in the zip archive. Arguments are otherwise the same as for :meth:`save_source_string`. r{r|ryrzN)r~_write)r:r]rr extensionrr4r4r5_write_source_strings z$PackageExporter._write_source_string)r]c CsVz|j|WStk rP}z$t|s*d|d}t|dW5d}~XYnXdS)NzModule not found: 'zW'. Make sure the PackageImporter that created this module is present in `self.importer`)rc import_moduleModuleNotFoundErrorr)r:r]rmsgr4r4r5_import_modules zPackageExporter._import_module)r]rcCs,z||WdStk r&YdSXdS)NTF)rrr:r]r4r4r5rs  zPackageExporter._module_exists)modulercCsFt|dd}|dks|ds"dn t||j}|dkrrLrr$r.rrr) r:r]rZ module_objrrrrOZpackaging_errorrrr4r4r5rsD     zPackageExporter._intern_moduler&)packageresourceobjrpickle_protocolcs|dks|dkstd||}t}t|j|d}j|_||| } t t d|d|d} j j | tjddd ttttd fd d } |r~g} d } d }t d }d}t| D]2\}}}|dkr|jdks|jdkrt|tst|} |}|||<n|jdks>|jdks>|jdkr`t|tsNt|} ||d }nP|jdkrv|d7}n:|jdkrt| tst| | kr| | | | |q|dkr|jdkrt|tst|d\} }| | kr| | | | |q| D]v}j | || krpt| ts2t| }j j |tjtjd|d|d|d|d ddn |q|| d S)a{Save a python object to the archive using pickle. Equivalent to :func:`torch.save` but saving into the archive rather than a stand-alone file. Stanard pickle does not save the code, only the objects. If ``dependencies`` is true, this method will also scan the pickled objects for which modules are required to reconstruct them and save the relevant code. To be able to save an object where ``type(obj).__name__`` is ``my_module.MyObject``, ``my_module.MyObject`` must resolve to the class of the object according to the ``importer`` order. When saving objects that have previously been packaged, the importer's ``import_module`` method will need to be present in the ``importer`` list for this to work. Args: package (str): The name of module package this resource should go in (e.g. ``"my_package.my_subpackage"``). resource (str): A unique name for the resource, used to identify it to load. obj (Any): The object to save, must be picklable. dependencies (bool, optional): If ``True``, we scan the source for dependencies. r'r&z4torch.package only supports pickle protocols 3 and 4)protocolT)rDr is_pickle)rfieldcslt|tstt|tst|r*dSjD]2\}}||r4|jtj kr`| |dSq4dS)ar checks if an object (field) comes from a mocked module and then adds the pair to mocked_modules which contains mocked modules paired with their list of mocked objects present in the pickle. We also hold the invariant that the first user defined rule that applies to the module is the one we use. N) rfrgrTrrvrRrrDr$r0rU)rrrrmocked_modulesr:r4r5_check_mocked_error^s    z8PackageExporter.save_pickle.._check_mocked_errorNrSHORT_BINUNICODE BINUNICODE8Z BINGET_LONGBINGETGETMEMOIZEr STACK_GLOBALGLOBAL z Object(s) 'z' from module `zC` was mocked out during packaging but is being used in resource - `z` in package `z`. )rDrMrOr) rT _filenamerVBytesIOrrc_persistent_id persistent_iddumpr[rrPrLrr$r.r rg pickletoolsZgenopsr8rfintrSrUsplitrr0r6rBrr)r:rrrrrrZdata_bufZpicklerZ data_valueZname_in_dependency_graphrZall_dependenciesrrmemoZ memo_countopcodeargposr]fieldsr4rr5 save_pickle1s               zPackageExporter.save_pickle)rrtextcCs||||dS)a5Save text data to the package. Args: package (str): The name of module package this resource should go it (e.g. ``"my_package.my_subpackage"``). resource (str): A unique name for the resource, used to identify it to load. text (str): The contents to save. utf-8) save_binaryencode)r:rrrr4r4r5 save_textszPackageExporter.save_text)binarycCs|||}|||dS)a3Save raw bytes to the package. Args: package (str): The name of module package this resource should go it (e.g. ``"my_package.my_subpackage"``). resource (str): A unique name for the resource, used to identify it to load. binary (str): The data to save. N)rr)r:rrrrr4r4r5rs zPackageExporter.save_binary)hookrcCst|j}||j|j<|S)aRegisters an extern hook on the exporter. The hook will be called each time a module matches against an :meth:`extern` pattern. It should have the following signature:: hook(exporter: PackageExporter, module_name: str) -> None Hooks will be called in order of registration. Returns: :class:`torch.utils.hooks.RemovableHandle`: A handle that can be used to remove the added hook by calling ``handle.remove()``. )rroidr:rhandler4r4r5register_extern_hooks  z$PackageExporter.register_extern_hookcCst|j}||j|j<|S)aRegisters a mock hook on the exporter. The hook will be called each time a module matches against a :meth:`mock` pattern. It should have the following signature:: hook(exporter: PackageExporter, module_name: str) -> None Hooks will be called in order of registration. Returns: :class:`torch.utils.hooks.RemovableHandle`: A handle that can be used to remove the added hook by calling ``handle.remove()``. )rrprrr4r4r5register_mock_hooks  z"PackageExporter.register_mock_hookcCst|j}||j|j<|S)aRegisters an intern hook on the exporter. The hook will be called each time a module matches against an :meth:`intern` pattern. It should have the following signature:: hook(exporter: PackageExporter, module_name: str) -> None Hooks will be called in order of registration. Returns: :class:`torch.utils.hooks.RemovableHandle`: A handle that can be used to remove the added hook by calling ``handle.remove()``. )rrqrrr4r4r5register_intern_hooks  z$PackageExporter.register_intern_hookr4)excluderEr)includerrEcCsttj||jt||d<dS)a&Specify modules that should be packaged. A module must match some ``intern`` pattern in order to be included in the package and have its dependencies processed recursively. Args: include (Union[List[str], str]): A string e.g. "my_package.my_subpackage", or list of strings for the names of the modules to be externed. This can also be a glob-style pattern, as described in :meth:`mock`. exclude (Union[List[str], str]): An optional pattern that excludes some patterns that match the include string. allow_empty (bool): An optional flag that specifies whether the intern modules specified by this call to the ``intern`` method must be matched to some module during packaging. If an ``intern`` module glob pattern is added with ``allow_empty=False``, and :meth:`close` is called (either explicitly or via ``__exit__``) before any modules match that pattern, an exception is thrown. If ``allow_empty=True``, no such exception is thrown. rN)rCr$r.rvrr:rrrEr4r4r5internszPackageExporter.interncCsttj||jt||d<dS)aReplace some required modules with a mock implementation. Mocked modules will return a fake object for any attribute accessed from it. Because we copy file-by-file, the dependency resolution will sometimes find files that are imported by model files but whose functionality is never used (e.g. custom serialization code or training helpers). Use this function to mock this functionality out without having to modify the original code. Args: include (Union[List[str], str]): A string e.g. ``"my_package.my_subpackage"``, or list of strings for the names of the modules to be mocked out. Strings can also be a glob-style pattern string that may match multiple modules. Any required dependencies that match this pattern string will be mocked out automatically. Examples : ``'torch.**'`` -- matches ``torch`` and all submodules of torch, e.g. ``'torch.nn'`` and ``'torch.nn.functional'`` ``'torch.*'`` -- matches ``'torch.nn'`` or ``'torch.functional'``, but not ``'torch.nn.functional'`` exclude (Union[List[str], str]): An optional pattern that excludes some patterns that match the include string. e.g. ``include='torch.**', exclude='torch.foo'`` will mock all torch packages except ``'torch.foo'``, Default: is ``[]``. allow_empty (bool): An optional flag that specifies whether the mock implementation(s) specified by this call to the :meth:`mock` method must be matched to some module during packaging. If a mock is added with ``allow_empty=False``, and :meth:`close` is called (either explicitly or via ``__exit__``) and the mock has not been matched to a module used by the package being exported, an exception is thrown. If ``allow_empty=True``, no such exception is thrown. rN)rCr$r0rvrrr4r4r5mocks%zPackageExporter.mockcCsttj||jt||d<dS)aInclude ``module`` in the list of external modules the package can import. This will prevent dependency discovery from saving it in the package. The importer will load an external module directly from the standard import system. Code for extern modules must also exist in the process loading the package. Args: include (Union[List[str], str]): A string e.g. ``"my_package.my_subpackage"``, or list of strings for the names of the modules to be externed. This can also be a glob-style pattern, as described in :meth:`mock`. exclude (Union[List[str], str]): An optional pattern that excludes some patterns that match the include string. allow_empty (bool): An optional flag that specifies whether the extern modules specified by this call to the ``extern`` method must be matched to some module during packaging. If an extern module glob pattern is added with ``allow_empty=False``, and :meth:`close` is called (either explicitly or via ``__exit__``) before any modules match that pattern, an exception is thrown. If ``allow_empty=True``, no such exception is thrown. rN)rCr$r/rvrrr4r4r5externAszPackageExporter.externr)rrcCs ttjdd|jt||d<dS)aOBlocklist modules who names match the given glob patterns from the list of modules the package can import. If a dependency on any matching packages is found, a :class:`PackagingError` is raised. Args: include (Union[List[str], str]): A string e.g. ``"my_package.my_subpackage"``, or list of strings for the names of the modules to be externed. This can also be a glob-style pattern, as described in :meth:`mock`. exclude (Union[List[str], str]): An optional pattern that excludes some patterns that match the include string. T)rErN)rCr$r1rvr)r:rrr4r4r5deny`s zPackageExporter.denyc Cstt|st|tjjrt|tjjrP|j}|}tt|}|j}| }n>t|tj r||}t t |}tj }|}ntdt |tt|}t|}|j|} |j|} | s|jj dkr|}|} |jd| d|| d|| ||fSt|drptr,t|tjjr,td|j !t"|dkrbdt"|f|#||j t"|<|j t"|SdS) Nzstorage type not recognized: cpuz.data/z.storagestorage__reduce_package__zSerializing ScriptModules directly into a package is a beta feature. To use, set global `torch.package.package_exporter._gate_torchscript_serialization` to `False`.Zreduce_package)$reZ is_storagerfrZ _TypedStorageZ_storageZpickle_storage_typerdtypesizeZ_UntypedStoragerruZuint8nbytes RuntimeErrorrrrrnZ has_storageZget_or_add_storageZdevicerri write_recordZdata_ptrr_gate_torchscript_serializationZjitZRecursiveScriptModulerrlrSrr) r:rZuntyped_storageZstorage_type_strZ storage_typerZ storage_numelrlocationZstorage_presentZ storage_id num_bytesr4r4r5rnsV           zPackageExporter._persistent_idcCs|SNr4r9r4r4r5 __enter__szPackageExporter.__enter__cCs |dk r|dS|dSr) _finalize_zipclose)r:exc_type exc_value tracebackr4r4r5__exit__szPackageExporter.__exit__cCsj||jkrtd|d|j|t|r>td|dt|trR|d}|j||t |dS)NzTried to write file 'z<', but it already exists in this archive. Please file a bug.z+Tried to save a torch.package'd module as 'z:'. Directly saving torch.package'd modules is not allowed.r) rkrTaddrrfrgrrirr)r:rZ str_or_bytesr4r4r5rs      zPackageExporter._writecCs\|jjD]\}}d|kr t|jq |jD]$\}}|js2|js2td|dq2dS)NrMz&Exporter did not match any modules to z', which was marked as allow_empty=False)rLrQrRrKrvrErFrJ)r:r]r^rrr4r4r5_validate_dependency_graphs   z*PackageExporter._validate_dependency_graphcCs4d|jkr0tttjd}|jdt|dddS)Nz_mock.pyrF)r)rkrgrrparentrr)r:Z mock_filer4r4r5_write_mock_files z PackageExporter._write_mock_filec Csn|g}|jjD]4\}}|d}|tjkrZ|jD]}|||q>||q|tj kr|j D]}|||qn| t | |d}||t|q|tjkr|jD]}|||qd|krtd||ddkrq|d}|d}||||q|tjkr(| q|tjkr8qqtd |d |d qd |d }|d |dS)zTakes a finalized dependency graph describing how to package all modules and executes it, writing to the ZIP archive. rDrrz-Module was marked `intern` but not provided: rTrrzInvalid action: z, z!. Please report a bug to PyTorch.rNz.data/extern_modulesN)r rLrQrRr$r/rovaluesrUr0rprrrr _MOCK_IMPLr.rqrTrSr2r3rr) r:Zextern_modulesr]r^rDrrrZextern_file_contentsr4r4r5_execute_dependency_graphsF          z)PackageExporter._execute_dependency_graphcCs|dtdS)zSWrites the python version that the package was created with to .data/python_versionz.data/python_versionN)rplatformpython_versionr9r4r4r5_write_python_version sz%PackageExporter._write_python_versioncCs&|||j|dS)zWrite the package to the filesystem. Any calls after :meth:`close` are now invalid. It is preferable to use resource guard syntax instead:: with PackageExporter("file.zip") as e: ... N)rrrmZ write_filesrr9r4r4r5rs zPackageExporter.closecCs|`|jr|jdS)zUCalled at the very end of packaging to leave the zipfile in a closed but valid state.N)rirhflushr9r4r4r5rszPackageExporter._finalize_zipcCs"|dd}t|}|d|S)Nryrz)r~r)r:rr package_pathr4r4r5r$s zPackageExporter._filenamecCs&|dd}|dkp$|tko$t|S)Nryrre) partition_DISALLOWED_MODULESr)r:r]Ztop_level_package_namer4r4r5r)s z&PackageExporter._can_implicitly_externcCs |jS)zReturns digraph string representation of dependencies in package. Returns: A string representation of dependencies in package. )rLZto_dotr9r4r4r5dependency_graph_string0sz'PackageExporter.dependency_graph_string)rDrcCsLg}|jjD].\}}|dd}||krd|kr||q||S)NrDr)rLrQrRrSrUsort)r:rDrr8Z node_dictZ node_actionr4r4r5_nodes_with_action_type8s  z'PackageExporter._nodes_with_action_typecCs |tjS)zReturn all modules that are currently externed. Returns: A list containing the names of modules which will be externed in this package. )rr$r/r9r4r4r5externed_modulesCsz PackageExporter.externed_modulescCs |tjS)zReturn all modules that are currently interned. Returns: A list containing the names of modules which will be interned in this package. )rr$r.r9r4r4r5interned_modulesLsz PackageExporter.interned_modulescCs |tjS)zReturn all modules that are currently mocked. Returns: A list containing the names of modules which will be mocked in this package. )rr$r0r9r4r4r5rUszPackageExporter.mocked_modulescCs |tjS)zReturn all modules that are currently denied. Returns: A list containing the names of modules which will be denied in this package. )rr$r1r9r4r4r5denied_modules^szPackageExporter.denied_modulescCs,||jjkr$t|jj|SgSdS)zReturn a list of all modules which depend on the module ``module_name``. Returns: A list containing the names of modules which depend on ``module_name``. N)rLZ_predrrPrr4r4r5 get_rdepsgszPackageExporter.get_rdeps)rdstrcCs|j||S)zReturn a dot representation of the subgraph that has all paths from src to dst. Returns: A dot representation containing all paths from src to dst. (https://graphviz.org/doc/info/lang.html) )rL all_paths)r:rr r4r4r5r!rszPackageExporter.all_pathsN)T)FT)F)T)T)Tr&)Ar*r+r,r-r rHr"rrgrrr rGrrrIr rrrrrtypes ModuleTyper rrrrrrrrbytesr ActionHookrrrrrrrrrrr rr rrrrrrrrr$rrrrrrr!r4r4r4r5r#s   : 6 5 #   ; =     - 6  8        sysrVz~from _mock import MockedObject def __getattr__(attr: str): return MockedObject(__name__ + '.' + attr, _suppress_err=True) )rrc Cs4t|d }|}|dW5QRSQRXdS)Nrbr)openreaddecode)rrdbr4r4r5rs r)ErrZimportlib.machineryrrVrrrr"rrZ dataclassesrenumrpathlibrtypingrrr r r r r rrrrreZtorch.serializationrrZ torch.typesrZtorch.utils.hooksrZ_digraphrZ _importlibrZ _manglingrrZ_package_picklerrZ_stdlibrZfind_file_dependenciesrZ glob_grouprrrcr r!r"rrgr%r$r6rCrrJrKr#rrrr4r4r4r5sT   4       #k