icfSSKJr SSKrSSKrSSKrSSKrSSKJr SSKJ r SSK J r SSK r SSKJrJr SSKJr SSKJr SS KJr SS KJr \R0"\5r\"\R85r0rS4S jrS5S jr S6Sjr!S6Sjr"S6Sjr#\RHS7Sj5r%S8S9Sjjr&S:Sjr'S;Sjr(SSjr,Sr-S?Sjr.S@SASjjr/S7Sjr0S>Sjr1SBSjr2S>Sjr3S S!4SCS"jjr4S#r5SDS$jr6/S%Qr7S\74SES&jjr8SFSGS'jjr9SHSIS(jjr:SJSKS)jjr;SLS*jrSOS.jr?S@SPS/jjr@SQS0jrA\R(aSS1KCJDrE g\R(aSS2KGJHrI \RS3\I5 CIgg)R) annotationsN)Pathdeque)Callable)HOMEPATHcompat)log) PostGraphAPI)isolated)importlib_metadataTcSSKJn Uc0n[R"[R 5nUR U5 [RRUS[/-5nSU;a0[RRURS5U/5nXTS'U(a&[R"USU06nUR5$[R"USU06$)z Executes an externally spawned Python interpreter. If capture_stdout is set to True, returns anything that was emitted in the standard output as a single string. Otherwise, returns the exit code. r)CONFpathex PYTHONPATHenv)PyInstaller.configrcopydeepcopyosenvironupdatepathsepjoinrgetr exec_pythonstripexec_python_rc)cmdrcapture_stdoutrpp_envpptxts MC:\des-py\RoboSAPF\venv\Lib\site-packages\PyInstaller\utils\hooks\__init__.py__exec_python_cmdr%-s ( { ]]2:: &F MM# h8*4 5Bv ZZ__fjj6; <<  #262yy{$$c6v66cH[R"U5nSU/n[X!S9$)Nz-cr )textwrapdedentr%) statementr rs r$__exec_statementr,Is% *I  C S @@r&c[USS9$)a Execute a single Python statement in an externally-spawned interpreter, and return the resulting standard output as a string. Examples:: tk_version = exec_statement("from _tkinter import TK_VERSION; print(TK_VERSION)") mpl_data_dir = exec_statement("import matplotlib; print(matplotlib.get_data_path())") datas = [ (mpl_data_dir, "") ] Notes: As of v5.0, usage of this function is discouraged in favour of the new :mod:`PyInstaller.isolated` module. Tr(r,r+s r$exec_statementr0Os" Id ;;r&c[USS9$)z^ Executes a Python statement in an externally spawned interpreter, and returns the exit code. Fr(r.r/s r$exec_statement_rcr2cs Ie <._can_import_modules$  { #  s  F)r decorateSubprocessDiedError)r?ris r$can_import_modulermsD(!+..  ' 's  77c[RS5nU"X5$![an[SUSU35UeSnAff=f)ak Get the string value of the passed attribute from the passed module if this attribute is defined by this module _or_ raise `AttributeError` otherwise. Since modules cannot be directly imported during analysis, this function spawns a subprocess importing this module and returning the string value of this attribute in this module. Parameters ---------- module_name : str Fully-qualified name of this module. attr_name : str Name of the attribute in this module to be retrieved. Returns ---------- str String value of this attribute. Raises ---------- AttributeError If this attribute is undefined. cBSSKnURU5n[X15$Nr)r9r=getattr)r? attr_namer9modules r$_get_module_attribute3get_module_attribute.._get_module_attributes ((5v))r&zFailed to retrieve attribute z from module N)r rkrgAttributeError)r?rrrtes r$get_module_attributerxs]2** k$[<< k._get_module_file_attributeJs}   !^^--g6==F**73H   # #G ,zz ^Y C   sAA''BBz:Failed to obtain the __file__ attribute of package/module !) r|r}r~rrrrvrrr rkrg)rrar9rrrws r$get_module_file_attributer&s, H '  !^^--g6==F**73H (j-g6 O=^Y C   6 jVW^V__`abhiijs*AA/%B/B  B  B.B))B.c[US5$)a Get the absolute path of the PyWin32 DLL specific to the PyWin32 module with the passed name (`pythoncom` or `pywintypes`). On import, each PyWin32 module: * Imports a DLL specific to that module. * Overwrites the values of all module attributes with values specific to that DLL. This includes that module's `__file__` attribute, which then provides the absolute path of that DLL. This function imports the module in isolated subprocess and retrieves its `__file__` attribute. r)rxrhs r$!get_pywin32_module_file_attributergs Z 88r&c[RRU5n[R"UR 5nUR(dgURRUSS9$![R a gf=f)a Check if a :pep:`0508` requirement is satisfied. Usually used to check if a package distribution is installed, or if it is installed and satisfies the specified version requirement. Parameters ---------- requirement : str Requirement string in :pep:`0508` format. Returns ---------- bool Boolean indicating whether the requirement is satisfied or not. Examples -------- :: # Assume Pillow 10.0.0 is installed. >>> from PyInstaller.utils.hooks import check_requirement >>> check_requirement('Pillow') True >>> check_requirement('Pillow < 9.0') False >>> check_requirement('Pillow >= 9.0, < 11.0') True FT) prereleases) packaging requirements Requirementr versionnamePackageNotFoundError specifiercontains) requirementparsed_requirementrs r$check_requirementrzs}:#//;;KH$,,-?-D-DE  ' '  ' ' 0 0d 0 KK  2 2s A--BBcPUb [S5eUb [S5e[U5$)a A compatibility wrapper for :func:`check_requirement`, intended for backwards compatibility with existing hooks. In contrast to original implementation from PyInstaller < 6, this implementation only checks the specified :pep:`0508` requirement string; i.e., it tries to retrieve the distribution metadata, and compare its version against optional version specifier(s). It does not attempt to fall back to checking the module's version attribute, nor does it support ``version`` and ``version_attr`` arguments. Parameters ---------- requirements : str Requirements string passed to the :func:`check_requirement`. version : None Deprecated and unsupported. Must be ``None``. version_attr : None Deprecated and unsupported. Must be ``None``. Returns ---------- bool Boolean indicating whether the requirement is satisfied or not. Raises ---------- ValueError If either ``version`` or ``version_attr`` are specified and are not None. zKCalling is_module_satisfies with version argument is not supported anymore.zPCalling is_module_satisfies with version argument_attr is not supported anymore.)rr)rr version_attrs r$is_module_satisfiesrs4@fggkll \ **r&cTSSjnSU;aU"U5$[R"X5$)z Check if a Python module is really a module or is a package containing other modules, without importing anything in the main process. :param module_name: Module name to check. :return: True if module is a package else otherwise. cSSKnURRU5n[UR5=(d UR R S5$![a gf=f)a Determines whether the given name represents a package or not. If the name represents a top-level module or a package, it is not imported. If the name represents a sub-module or a sub-package, its parent is imported. In such cases, this function should be called from an isolated suprocess. NOTE: the fallback check for `__init__.py` is there because `_distutils_hack.DistutilsMetaFinder` from `setuptools` does not set spec.submodule_search_locations for `distutils` / `setuptools._distutils` even though it is a package. The alternative would be to always perform full import, and check for the `__path__` attribute, but that would also always require full isolation. rNz __init__.pyF)r|r}r~boolsubmodule_search_locationsoriginrZrg)r?r9specs r$ _is_packageis_package.._is_packagesV  !>>++K8D778_DKK._get_package_pathssf  !>>++G4Dt>> *.*I*IJ*I$CI*IJ JJ I s(8A&A& A!A&!A&& A54A5rzrrr)rr pkg_pathss r$get_all_package_pathsrs: & '&w/  MM"4> r&cT[XRS[R55$)a& Given a package location path and package name, return the package base path, i.e., the directory in which the top-level package is located. For example, given the path ``/abs/path/to/python/libs/pkg/subpkg`` and package name ``pkg.subpkg``, the function returns ``/abs/path/to/python/libs``. rz)r\replacersep) package_pathrs r$package_base_pathrs sBFF'C DDr&c[U5nU(d[SUS35e[U5S:a[R SX5 USn[ X 5nX24$)a Given a package, return the path to packages stored on this machine and also returns the path to this particular package. For example, if pkg.subpkg lives in /abs/path/to/python/libs, then this function returns ``(/abs/path/to/python/libs, /abs/path/to/python/libs/pkg/subpkg)``. NOTE: due to backwards compatibility, this function returns only one package path along with its base directory. In case of PEP 420 namespace package with multiple location, only first location is returned. To obtain all package paths, use the ``get_all_package_paths`` function and obtain corresponding base directories using the ``package_base_path`` helper. z Package 'z%' does not exist or is not a package!zQget_package_paths - package %s has multiple paths (%r); returning only first one!r)rrrUrIwarningr)rrpkg_dirpkg_bases r$get_package_pathsrsb&g.I 9WI-RSTT 9~ _ah lG 2H  r&cgNTrs r$r9sr& warn oncec[U[5(d [S5eUS;a[SUS35e[R SU5 [ U5(d+[R SU5 [U5(aU/$/$/n[5nURU5 [R"5nU(a~UR5nUR[Xb5upxnX7V s/sHo"U 5(dMU PM sn - nUH#n U"U 5(dMURU 5 M% U(aM~SSS5 [U5n[R SU5 U$s sn f!,(df  N6=f) a7 List all submodules of a given package. Arguments: package: An ``import``-able package. filter: Filter the submodules found: A callable that takes a submodule name and returns True if it should be included. on_error: The action to take when a submodule fails to import. May be any of: - raise: Errors are reraised and terminate the build. - warn: Errors are downgraded to warnings. - warn once: The first error issues a warning but all subsequent errors are ignored to minimise *stderr pollution*. This is the default. - ignore: Skip all errors. Don't warn about anything. Returns: All submodules to be assigned to ``hiddenimports`` in a hook. This function is intended to be used by hook scripts, not by main PyInstaller code. Examples:: # Collect all submodules of Sphinx don't contain the word ``test``. hiddenimports = collect_submodules( "Sphinx", ``filter=lambda name: 'test' not in name) .. versionchanged:: 4.5 Add the **on_error** parameter. package must be a str)ignorerwarnraisezInvalid on-error action 'z:': Must be one of ('ignore', 'warn once', 'warn', 'raise')zCollecting submodules for %sz)collect_submodules - %s is not a package.Nz)collect_submodules - found submodules: %s) isinstancerrrrIrJrrmrrGr Pythonpopr_collect_submodulessorted) rfilteron_errorpackage_submodulestodoisolated_pythonrr; subpackagesrssubpackage_names r$collect_submodulesr7sZN gs # #/00??'z1k l   LL/9 g   @'J W % %9   7DKK  o88:D-<-A-ABUW[-f *G( "Rf6&>6"R R $//**KK0$/d  23 LL<>PQ #S  s*95E/.E*E*E/!E/*E// E=c SSKnSSKnSSKJn SSKJn UR SU5 /n/n[U5 XR;aXgU4$[!URUSS5=(d /n U (dXgU4$UR#U5 UR SX 5 UR%XS-5H1upn U (dUR#U5 M UR#U5 M3 XgU4$![anUS;a`SSK Jn SRU"[U5U55R5nURSUSUS U35 US :XaS nXgU4sSnA$US :Xa[S US35UeSnAGN=SnAff=f)Nr)format_exception_only)rIz-collect_submodules - scanning (sub)package %s)rrr4z"Failed to collect submodules for 'z' because importing 'z ' raised: rrrzUnable to load subpackage 'z'.__path__z@collect_submodules - scanning (sub)package %s in location(s): %srz)r8pkgutil tracebackrPyInstaller.utils.hooksrIrJrfrgPyInstaller.logrtyperrrr;rqrG iter_modules) rrr8rrrIr;rexpathsimporterispkgs r$rrs/. LL@$GGK N4 ;;X-- CKK%z4 8 >BE X-- NN4 LLSUYa!(!5!5eCZ!H NN4   t $ "I  ))A  N , , ..tBx<=CCEB NN?vEZ[_Z``jkmjno p;&#1 1   ;D6DE2 M! Ns$ C(( E92A E4E9E44E9c@URUS-5=(d X:H$)a This helper function is designed for use in the ``filter`` argument of :func:`collect_submodules`, by returning ``True`` if the given ``name`` is a module or a submodule of ``mod_or_submod``. Examples: The following excludes ``foo.test`` and ``foo.test.one`` but not ``foo.testifier``. :: collect_submodules('foo', lambda name: not is_module_or_submodule(name, 'foo.test'))`` rz)rT)r mod_or_submods r$is_module_or_submodulers  ??=3. / H43HHr&)*.dllz*.dylibzlib*.soc .[RSU-5 [U[5(d [ S5e[ U5(d[R SU5 /$[U5n/nUHn[XP5nUHn[U5RU5nUHjn U(aUn OU RRU5n [RSU <SU <35 UR[U 5[U 545 Ml M M U$)a This function produces a list of (source, dest) of dynamic library files that reside in package. Its output can be directly assigned to ``binaries`` in a hook script. The package parameter must be a string which names the package. :param destdir: Relative path to ./dist/APPNAME where the libraries should be put. :param search_patterns: List of dynamic library filename patterns to collect. z#Collecting dynamic libraries for %srzZcollect_dynamic_libs - skipping library collection for module '%s' as it is not a package. z, )rIrJrrrrrrrrrglobparent relative_torG) rdestdirsearch_patternspkg_dirsdylibsrrpatternfilessourcedests r$collect_dynamic_libsrs LL6@A gs # #/00 g   hjq  $W-H F$W6&GM''0E"D"==44X>D &$78 s6{CI67 ' Mr&c ^ [RSU-5 [U[5(d [ S5e[ U5(d[R SU5 /$U(a [U5O/n[U5nU(d(U[RVs/sHnSU-PM sn- nO.U[RVs/sHofS;dM SU-PM sn- nURS5 U(a [U5OS/n[U5nU 4Sjn/n [U5n U Hn [5m [X5n U(a[R R#X5n U"XUS5 U"XUS 5 U T Vs/sH2n[U5[UR$R'U 554PM4 sn- n M [RS U 5 U $s snfs snfs snf) aX This function produces a list of ``(source, dest)`` entries for data files that reside in ``package``. Its output can be directly assigned to ``datas`` in a hook script; for example, see ``hook-sphinx.py``. The data files are all files that are not shared libraries / binary python extensions (based on extension check) and are not python source (.py) files or byte-compiled modules (.pyc). Collection of the .py and .pyc files can be toggled via the ``include_py_files`` flag. Parameters: - The ``package`` parameter is a string which names the package. - By default, python source files and byte-compiled modules (files with ``.py`` and ``.pyc`` suffix) are not collected; setting the ``include_py_files`` argument to ``True`` collects these files as well. This is typically used when a package requires source .py files to be available; for example, JIT compilation used in deep-learning frameworks, code that requires access to .py files (for example, to check their date), or code that tries to extend `sys.path` with subpackage paths in a way that is incompatible with PyInstaller's frozen importer.. However, in contemporary PyInstaller versions, the preferred way of collecting source .py files is by using the **module collection mode** setting (which enables collection of source .py files in addition to or in lieu of collecting byte-compiled modules into PYZ archive). - The ``subdir`` argument gives a subdirectory relative to ``package`` to search, which is helpful when submodules are imported at run-time from a directory lacking ``__init__.py``. - The ``excludes`` argument contains a sequence of strings or Paths. These provide a list of `globs `_ to exclude from the collected data files; if a directory matches the provided glob, all files it contains will be excluded as well. All elements must be relative paths, which are relative to the provided package's path (/ ``subdir`` if provided). Therefore, ``*.txt`` will exclude only ``.txt`` files in ``package``\ 's path, while ``**/*.txt`` will exclude all ``.txt`` files in ``package``\ 's path and all its subdirectories. Likewise, ``**/__pycache__`` will exclude all files contained in any subdirectory named ``__pycache__``. - The ``includes`` function like ``excludes``, but only include matching paths. ``excludes`` override ``includes``: a file or directory in both lists will be excluded. This function does not work on zipped Python eggs. This function is intended to be used by hook scripts, not by main PyInstaller code. zCollecting data files for %srzUcollect_data_files - skipping data collection for module '%s' as it is not a package.**/*>.py.pycz**/__pycache__/*.pycc V>[U5HupE[U5RU5HvnUR5(a5XB:a.UR [ US- R U555 MKMMU(aTRU5OTRU5 Mx M g)Nr) enumeraterglobis_dirrGrradddiscard)rcludes clude_len is_includeicgsourcess r$ clude_walker(collect_data_files..clude_walkerHsf%DA']''*88::} c1v:*B*B7*K&LM% '1GKKNgooa6H+&r&TFz$collect_data_files - Found files: %s)rIrJrrrrrr>rUr ALL_SUFFIXESrGrr:rrrPrrr)rinclude_py_filessubdirexcludesincludes excludes_lens includes_lenrdatasrrrrs @r$collect_data_filesrsT LL/'9: gs # #/00 g  npwx "*tH~rHx=L )<)<=)?QQ LL7? Lo>ZbRsG G G;9Gc[U[5(d [S5e/n[R"U5HupEnUHn[R R U5SnU(d U[;dM8[R RXG5n [[U5RU55n Ub[R RX5n URX45 M M U$)a  This function produces a list of (source, dest) non-Python (i.e., data) files that reside somewhere on the system. Its output can be directly assigned to ``datas`` in a hook script. This function is intended to be used by hook scripts, not by main PyInstaller code. zpath must be a strr) rrrrwalkrPr`PY_IGNORE_EXTENSIONSrrrrG) rPrrrdirpathdirnamesrf extensionrrs r$collect_system_data_filesrss dC ,-- E$&GGDM 5A((+A.II5I$Ig14=44T:;&77<<6D f^,%2 Lr&c SSKJn U"U/5n[5n/nU(GaUR5nX;aM[R "U5n[ US5(d[S[U5SUS35eURn[U[5(dURRURR- nUR5(aCURR!S5(a#[S[#U5<S U<S US US 3 5e[SU<S [U5S35eUR%5(arURS:XaUURRR!S5(a+[&R(R*"UR,SS6n O8URn O+UR5(aSn O[SU<SUS35eURRS:XaEURRRS:Xa![&R(R+SSU 5n UR/[#U5[#U 545 U(dU$UR1U5 UR2=(d /V s/sH"n [4R6R9U 5PM$ n n U V s/sH<oR:b!U R:R=5(dM0U RPM> n n X;- nU(aGMU$![a URnGNxf=fs sn fs sn f)a Collect distribution metadata so that ``importlib.metadata.distribution()`` or ``pkg_resources.get_distribution()`` can find it. This function returns a list to be assigned to the ``datas`` global variable. This list instructs PyInstaller to copy the metadata for the given package to the frozen application's data directory. Parameters ---------- package_name : str Specifies the name of the package for which metadata should be copied. recursive : bool If true, collect metadata for the package's dependencies too. This enables use of ``importlib.metadata.requires('package')`` or ``pkg_resources.require('package')`` inside the frozen application. Returns ------- list This should be assigned to ``datas``. Examples -------- >>> from PyInstaller.utils.hooks import copy_metadata >>> copy_metadata('sphinx') [('c:\python27\lib\site-packages\Sphinx-1.3.2.dist-info', 'Sphinx-1.3.2.dist-info')] Some packages rely on metadata files accessed through the ``importlib.metadata`` (or the now-deprecated ``pkg_resources``) module. PyInstaller does not collect these metadata files by default. If a package fails without the metadata (either its own, or of another package that it depends on), you can use this function in a hook to collect the corresponding metadata files into the frozen application. The tuples in the returned list contain two strings. The first is the full path to the package's metadata directory on the system. The second is the destination name, which typically corresponds to the basename of the metadata directory. Adding these tuples the the ``datas`` hook global variable, the metadata is collected into top-level application directory (where it is usually searched for). .. versionchanged:: 4.3.1 Prevent ``dist-info`` metadata folders being renamed to ``egg-info`` which broke ``pkg_resources.require`` with *extras* (see :issue:`#3033`). .. versionchanged:: 4.4.0 Add the **recursive** option. rr_pathzUnsupported distribution type z for z - does not have _path attributez.eggz"Cannot collect metadata from path zu, which appears to be inside a zipped egg. PyInstaller >= 6.0 does not support zipped eggs anymore. Please reinstall z using modern package installation method instead of deprecated 'python setup.py install'. For example, if you are using pip package manager: 1. uninstall the zipped egg: pip uninstall z 2. make sure pip and its dependencies are up-to-date: python -m pip install --upgrade pip setuptools 3. install the package: pip install zb To install a package from source, pass the path to the source directory to 'pip install' command.z, which is of unsupported type rzzEGG-INFONzDistribution metadata path z is neither file nor directory!_vendor setuptools) collectionsrr:rr distributionhasattr RuntimeErrorrrrrrrrgis_filerZrrrrPrpartsrGrrequiresrrrmarkerevaluate) package_name recursiverrdoneoutdistsrc_path src_parent dest_pathreqrs r$ copy_metadatar/s`" , D 5D C xxz   !..|< tW%%0d E,Oop ::(D))  -%__33hoo6J6JJ !!## (@(@(H(H"8X8IJaam`pq'(4n5%&2N3x x  #8 Dcdhiqdrcsstu ??  }} *x/C/C/L/LV/T/TGGLL(..*=> $MM     I-h\|nLkl  ??  9 ,1G1G1L1LP\1\ \9iHI CM3y>23J  LP==K^\^K^_K^C ..::3?K^ _,8hLSJJr&c^URRnSnX;aX#U;aX1UnU$)a| Get user settings for hooks. Args: module_name: The module/package for which the key setting belong to. key: A key for the config. Returns: The value for the config. ``None`` if not set. The ``get_hook_config`` function will lookup settings in the ``Analysis.hooksconfig`` dict. The hook settings can be added to ``.spec`` file in the form of:: a = Analysis(["my-app.py"], ... hooksconfig = { "gi": { "icons": ["Adwaita"], "themes": ["Adwaita"], "languages": ["en_GB", "zh_CN"], }, }, ... ) N)analysis hooksconfig)hook_apir?keyconfigvalues r$get_hook_configrNs<8   * *F E{(;!;#C( Lr&cUb'UH n[R"X5(dM O gUb&UH n[R"X5(dM g g)a Generic inclusion/exclusion decision function based on filename and list of include and exclude patterns. Args: filename: Filename considered for inclusion. include_list: List of inclusion file patterns. exclude_list: List of exclusion file patterns. Returns: A boolean indicating whether the file should be included or not. If ``include_list`` is provided, True is returned only if the filename matches one of include patterns (and does not match any patterns in ``exclude_list``, if provided). If ``include_list`` is not provided, True is returned if filename does not match any patterns in ``exclude list``, if provided. If neither list is provided, True is returned for any filename. FT)fnmatch)ra include_list exclude_listrs r$include_or_exclude_filerSsR0#Gx11$#Gx11$ r&c 6U=(d /nU=(d /nUcUS-n[R(dX#4$[U5upE[U5nXA- nUR 5(dX#4$X6R S5Vs/sH2n[ U5[ URRU554PM4 sn- nUUR S5Vs/sH2n[ U5[ URRU554PM4 sn- nX#4$s snfs snf)a Collect data files and binaries from the .libs directory of a delvewheel-enabled python wheel. Such wheels ship their shared libraries in a .libs directory that is located next to the package directory, and therefore falls outside the purview of the collect_dynamic_libs() utility function. Args: package_name: Name of the package (e.g., scipy). libdir_name: Optional name of the .libs directory (e.g., scipy.libs). If not provided, ".libs" is added to ``package_name``. datas: Optional list of datas to which collected data file entries are added. The combined result is retuned as part of the output tuple. binaries: Optional list of binaries to which collected binaries entries are added. The combined result is retuned as part of the output tuple. Returns: tuple: A ``(datas, binaries)`` pair that should be assigned to the ``datas`` and ``binaries``, respectively. Examples: Collect the ``scipy.libs`` delvewheel directory belonging to the Windows ``scipy`` wheel:: datas, binaries = collect_delvewheel_libs_directory("scipy") When the collected entries should be added to existing ``datas`` and ``binaries`` listst, the following form can be used to avoid using intermediate temporary variables and merging those into existing lists:: datas, binaries = collect_delvewheel_libs_directory("scipy", datas=datas, binaries=binaries) .. versionadded:: 5.6 z.libsrz.load[-_]order*) r is_winrrrrrrr) r& libdir_namerr>rrlibs_dirdll_fileload_order_files r$!collect_delvewheel_libs_directoryrZsF KRE~2H"W,  ==*,7HH~H%H ??    ]j]jkr]st]sQY#h-X__%@%@%J!KL]sttH  %-]]3D%EG%E/?#S)?)?)K)KH)U%VW%EGGE ?u Gs >9D9D)conda)CONDA_META_DIRzAssuming this is not an Anaconda environment or an additional venv/pipenv/... environment manager is being used on top, because the conda-meta folder %s does not exist.r)T)r+rr)r4)rNr)rVrrWr)rVrr[r)rar)r?rrrrr)rr)NN)rrrNonerr])rrrr)rrrzCallable[[str], bool]rr)rrrr)rrrz str | Nonerr>)FNNN) rrrrrstr | os.PathLike | Noner  list | Noner r_)NF)rPrrr^rr)F)r&rr'r)r4r) r&rrrr;rr<r_r=r_rr)rr)rJr r?rrKr)rarrQr_rRr_)NNN)K __future__rrrr)rPpathlibrrrtypingrpackaging.requirementsr PyInstallerrr r loggingPyInstaller.depend.imphookapir r PyInstaller.compatr getLogger__name__rIr:rrhook_variablesr%r,r0r2r6rkrArRrXr\rcrmrxrrrrrrrrrrrPY_DYLIB_PATTERNSrrrr/r8r@rFrNrSrZ is_pure_condarr[ conda_supportis_condaPyInstaller.utils.hooks.condar\_tmprrr&r$rqsm# (&6 1   8 $6../78A <(=2 DD26  )F#kL>B9&+Ld$+$+ $+$+N7DBE8%6P P !PPh/*d I>B[l'X#'+  s ss %s s  sl6M`1l""3!%!% 4*4*4* 4* 4*  4*  4*n@ J!% $$$$$NAH > __D NN HIM r&