archive.git - Gitblit

Ë  
hñúhc×ãóddlmZddlZddlZddlZddlZddlmZddlm    Z    ddl
mZddlZ ddlmZmZddlmZddlmZdd    lmZdd
lmZej0e«Zeej8«ZiZd4dZd5d Z d6dZ!d6dZ"d6dZ#ejHd7d«Z%d8d9dZ&d:dZ'd;dZ(d<dZ)d7dZ*d=dZ+d>dZ,dZ-d?dZ.        d@                    dAdZ/d7dZ0d>dZ1dBdZ2d>dZ3d d!f                    dCd"Z4d#Z5dDd$Z6gd%¢Z7de7fdEd&Z8                dF                                    dGd'Z9dHdId(Z:dJdKd)Z;dLd*Z<dd+ddd!f                                            dMd,Z=dNd-Z>dOd.Z?        d@                    dPd/Z@dQd0ZAejrdd1lCmDZEyejrdd2lGmHZIejd3eI«[Iyy)Ré)ÚannotationsN)ÚPath©Údeque)ÚCallable)ÚHOMEPATHÚcompat)Úlog)ÚPostGraphAPI)Úisolated)Úimportlib_metadataTcó¼ddlm}|i}tjtj
«}|j |«tjj|dtgz«}d|vr0tjj|jd«|g«}||d<|r%tj|d|i}|j«Stj|d|iS)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)ÚCONFÚpathexÚ
PYTHONPATHÚenv)ÚPyInstaller.configrÚcopyÚdeepcopyÚosÚenvironÚupdateÚpathsepÚjoinrÚgetr    Úexec_pythonÚstripÚexec_python_rc)ÚcmdrÚcapture_stdoutrÚpp_envÚppÚtxts       úSH:\Change_password\venv_build\Lib\site-packages\PyInstaller/utils/hooks/__init__.pyÚ__exec_python_cmdr%-s¼õ(Ø
{Øä ]]2::Ó &FØ
MM#Ôô
h¬8¨*Ñ4Ó    5BðvÑÜ ZZ__fjj¨Ó6¸Ð;Ó <ØF<ÑáÜ× Ñ  #Ð2¨6Ñ2Øyy{Ðä×$Ñ$ cÐ6¨vÑ6Ð6ócóNtj|«}d|g}t||¬«S)Nz-c©r )ÚtextwrapÚdedentr%)Ú    statementr rs   r$Ú__exec_statementr,Is'Ü     Ó*IØÐ
CÜS°Ô@Ð@r&cót|d¬«S)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ô"I°dÔ;Ð;r&cót|d¬«S)zf
    Executes a Python statement in an externally spawned interpreter, and returns the exit code.
    Fr(r.r/s r$Úexec_statement_rcr2csôI°eÔ<Ð<r&cóPt|«j«}|syt|«S)aë
    Execute a single Python statement in an externally-spawned interpreter, and :func:`eval` its output (if any).
 
    Example::
 
      databases = eval_statement('''
         import sqlalchemy.databases
         print(sqlalchemy.databases.__all__)
         ''')
      for db in databases:
         hiddenimports.append("sqlalchemy.databases." + db)
 
    Notes:
        As of v5.0, usage of this function is discouraged in favour of the
        new :mod:`PyInstaller.isolated` module.
 
    Ú)r0rÚeval)r+r#s  r$Úeval_statementr6js'ô$Ó
#×
)Ñ
)Ó
+CÙàÜ9Ðr&cóàddl}ddl}t|jj    ««}|j|«t t|jj    ««|z
|hz
«S)aÇ
    Return list of modules required by binary (C/C++) Python extension.
 
    Python extension files ends with .so (Unix) or .pyd (Windows). It is almost impossible to analyze binary extension
    and its dependencies.
 
    Module cannot be imported directly.
 
    Let's at least try import it in a subprocess and observe the difference in module list from sys.modules.
 
    This function could be used for 'hiddenimports' in PyInstaller hooks files.
    rN)ÚsysÚ    importlibÚsetÚmodulesÚkeysÚ import_moduleÚlist)Úmodule_namer8r9Úoriginals    r$Úget_pyextension_importsrAs\óÛä3;;×#Ñ#Ó%Ó&Hð×ÑKÔ(ôCKK×$Ñ$Ó&Ó'¨(Ñ2°k°]ÑBÓCÐCr&códdl}ddg}d}|r|j|«d|z}nd}    |j|«j«}tjd|d|d    «|r|jd«Sy#t$rtjd
«Y4|j$rtjd|z«Y\wxYw) z§
    Return the homebrew path to the requested formula, or the global prefix when called with no argument.
 
    Returns the path as a string or None if not found.
    rNÚbrewz--prefixzhomebrew formula "%s"zhomebrew prefixzFound z at "ú"zDetected homebrew not installedz#homebrew formula "%s" not installedÚutf8)    Ú
subprocessÚappendÚcheck_outputrÚloggerÚdebugÚOSErrorÚCalledProcessErrorÚdecode)ÚformularFÚbrewcmdÚpathÚdbgstrs     r$Úget_homebrew_pathrRs»óØzÐ"GØDÙØwÔØ(¨7Ñ2à"ðFØ×&Ñ& wÓ/×5Ñ5Ó7Üª6²4Ð8Ô9ñ
Ø{{6Ó"Ð"àøôò8ÜÐ6Ö7Ø×(Ñ(òFÜÐ:¸WÑDÖEðFús§;A6Á6B?Â&B?Â>B?cóD|j|«r|t|«dS|S)z
    This function removes the given prefix from a string, if the string does indeed begin with the prefix; otherwise,
    it returns the original string.
    N)Ú
startswithÚlen)ÚstringÚprefixs  r$Ú remove_prefixrX¸s(ð
×ÑÔ Øc&klÐ#Ð#à r&cóJ|r |j|«r|dt|«S|S)z
    This function removes the given suffix from a string, if the string does indeed end with the suffix; otherwise,
    it returns the original string.
    N)ÚendswithrU)rVÚsuffixs  r$Ú remove_suffixr\Ãs*ñ&// &Ô)ØmF|Ð$Ð$à r&có¾tjD])}|j|«s|d|j|«cStj
j |«dS)z
    This function returns filename without its extension.
 
    For Python C modules it removes even whole '.cpython-34m.so' etc.
    r)r    ÚEXTENSION_SUFFIXESrZÚrfindrrPÚsplitext)ÚfilenameÚsuffs  r$Úremove_file_extensionrcÐsYô×)Ñ)ò4Ø×ÑTÕ"ØAhnn¨TÓ2Ð3Ò3ð4ô77×ÑHÓ% aÑ(Ð(r&córtjd«}    ||«S#tj$rYywxYw)a
    Check if the specified module can be imported.
 
    Intended as a silent module availability check, as it does not print ModuleNotFoundError traceback to stderr when
    the module is unavailable.
 
    Parameters
    ----------
    module_name : str
        Fully-qualified name of the module.
 
    Returns
    ----------
    bool
        Boolean indicating whether the module can be imported or not.
    có:    t|«y#t$rYywxYw)NTF)Ú
__import__Ú    Exception©r?s r$Ú_can_import_modulez-can_import_module.<locals>._can_import_moduleñs$ð    Ü{Ô#ØøÜò    Ùð    ús    F)rÚdecorateÚSubprocessDiedError)r?ris  r$Úcan_import_modulerlÝsDô(×ÑñóððÙ! +Ó.Ð.øÜ×'Ñ'òÙðús  6µ6cótjd«}    |||«S#t$r}td|d|«|d}~wwxYw)a·
    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.
    cóDddl}|j|«}t||«S©Nr)r9r=Úgetattr)r?Ú    attr_namer9Úmodules    r$Ú_get_module_attributez3get_module_attribute.<locals>._get_module_attributes"ãØ×(Ñ(¨Ó5ÜvyÓ)Ð)r&zFailed to retrieve attribute z  from module N)rrjrgÚAttributeError)r?rqrsÚes    r$Úget_module_attributervs_ô2×Ññ*óð*ðkÙ$ [°)Ó<Ð<øÜòkÜÐ<¸Y¸KÀ}ÐU`ÐTaÐbÓcÐijÐjûðkús!¡    Aª<¼AcóPd}d|vr@    ddl}|jj|«j}|j    |«}|r|S    tjd«}    ||«}|S#t
tttf$rY<wxYw#t$r}td|d«|d}~wwxYw)aù
    Get the absolute path to the specified module or package.
 
    Modules and packages *must not* be directly imported in the main process during the analysis. Therefore, to
    avoid leaking the imports, this function uses an isolated subprocess when it needs to import the module and
    obtain its ``__file__`` attribute.
 
    Parameters
    ----------
    package : str
        Fully-qualified name of module or package.
 
    Returns
    ----------
    str
        Absolute path of this module.
    Nú.rcó    ddl}|jj|«j}|j    |«}|r|S    ddl    }|j|«}|jS#t
tttf$rY<wxYwro)Úimportlib.utilÚutilÚ    find_specÚloaderÚget_filenameÚImportErrorrtÚ    TypeErrorÚ
ValueErrorr9r=Ú__file__)Úpackager9r}raÚps     r$Ú_get_module_file_attributez=get_module_file_attribute.<locals>._get_module_file_attributeJs}ð
    Û!Ø^^×-Ñ-¨gÓ6×=Ñ=FØ×*Ñ*¨7Ó3HáØðó    Ø×#Ñ# GÓ,ØzzÐøô ^¬Y¼
ÐCò    Ùð    ús=A"Á"A>Á=A>z:Failed to obtain the __file__ attribute of package/module ú!)rzr{r|r}r~rrtrrrrjrg)rrar9r}rrus      r$Úget_module_file_attributer&sÎð, HØ
'Ñð        Û!Ø^^×-Ñ-¨gÓ6×=Ñ=FØ×*Ñ*¨7Ó3HñØðô×Ññóðð(jÙ-¨gÓ6ðOøô=^¬Y¼
ÐCò    Ùð    ûô6òjÜÐVÐW^ÐV_Ð_`ÐaÓbÐhiÐiûðjús)=A(ÁBÁ(BÂBÂ    B%ÂB Â B%cót|d«S)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)rvrhs r$Ú!get_pywin32_module_file_attributergsô   ¨ZÓ8Ð8r&cótjj|«}    tj|j
«}|jsy|jj|d¬«S#tj$rYywxYw)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 ÚversionÚnameÚPackageNotFoundErrorÚ    specifierÚcontains)ÚrequirementÚparsed_requirementrs   r$Úcheck_requirementrzs}ô:#×/Ñ/×;Ñ;¸KÓHÐðÜ$×,Ñ,Ð-?×-DÑ-DÓEð
×'Ò'Øð×'Ñ'×0Ñ0°ÀdÐ0ÓKÐKøô×2Ñ2òÙðús¡A*Á*BÁ?BcóL|td«|td«t|«S)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_satisfiesrªs4ð@ÐÜÐfÓgÐgØÐÜÐkÓlÐlÜ\Ó*Ð*r&cóNdd}d|vr||«Stj||«S)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.
    cóÄ    ddl}|jj|«}t|j«xs|j
j d«S#t$rYywxYw)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)rzr{r|ÚboolÚsubmodule_search_locationsÚoriginrZrg)r?r9Úspecs   r$Ú_is_packagezis_package.<locals>._is_packageÙsVð    Û!Ø>>×+Ñ+¨KÓ8DÜ×7Ñ7Ó8Ò_¸D¿K¹K×<PÑ<PÐQ^Ó<_Ð_øÜò    Ùð    úsAAÁ    AÁArx©r?Ústr©rÚcall)r?r s  r$Ú
is_packager¥Ñs-óð(+ÑÙ;Ó'Ð'ä}}[¨+Ó6Ð6r&cóVdd}d|vr
||«}|Stj||«}|S)a
    Given a package name, return all paths associated with the package. Typically, packages have a single location
    path, but PEP 420 namespace packages may be split across multiple locations. Returns an empty list if the specified
    package is not found or is not a package.
    cóÔ    ddl}|jj|«}|r|jsgS|jDcgc] }t    |«c}Scc}w#t
$rgcYSwxYw)aç
        Retrieve package path(s), as advertised by submodule_search_paths attribute of the spec obtained via
        importlib.util.find_spec(package). If the name represents a top-level package, the package 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. Returns an empty list if specified package is not found or is not
        a package.
        rN)rzr{r|rr¢rg)rr9rrPs    r$Ú_get_package_pathsz1get_all_package_paths.<locals>._get_package_pathsùs`ð    Û!Ø>>×+Ñ+¨GÓ4DÙt×>Ò>Ø    Ø*.×*IÑ*IÖJ $CIÒJÐJùÒJøÜò    ØIð    ús'.A±A¿AÁAÁAÁA'Á&A'rx©rr¢r£)rr¨Ú    pkg_pathss   r$Úget_all_package_pathsr«ós<óð&'ÑÙ& wÓ/    ðÐôMMÐ"4°gÓ>    àÐr&cóVt||jdtj««S)a6
    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``.
    rx)r\ÚreplacerÚsep)Úpackage_pathrs  r$Úpackage_base_pathr°s ô w§¡°s¼B¿F¹FÓ'CÓDÐDr&có®t|«}|std|d«t|«dkDrtj    d||«|d}t||«}||fS)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)r«rrUrIÚwarningr°)rrªÚpkg_dirÚpkg_bases    r$Úget_package_pathsr¶siô& gÓ.IÙÜ9 W IÐ-RÐSÓTÐTä
9~ÒÜØ_ÐahÐjsô    
ðlGÜ  ¨'Ó2HàWÐÐr&cóy©NT©©rs r$ú<lambda>r»9ór&ú    warn oncecó¢t|t«std«|dvrtd|d«tjd|«t |«s&tjd|«t|«r|gSgSg}t«}|j|«tj«5}|rk|j«}|jt||«\}}}||D    cgc] }    ||    «s|    c}    z }|D]}
||
«s|j|
«|rkddd«t|«}tjd|«|Scc}    w#1swY1xYw)    a
    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)Úignorer½ÚwarnÚraisezInvalid 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)Ú
isinstancer¢rrrIrJr¥rlrrGrÚPythonÚpopr¤Ú_collect_submodulesÚsorted)rÚfilterÚon_errorÚpackage_submodulesÚtodoÚisolated_pythonrr;ÚsubpackagesrrÚsubpackage_names           r$Úcollect_submodulesrÏ7sYôNgsÔ#ÜÐ/Ó0Ð0ØÐ?Ñ?ÜØ'¨ zÐ1kÐló
ð    
ôLLÐ/°Ô9ôgÔÜÐ@À'ÔJôWÔ%Ø9ÐØ    ðÐä7DØKKÔä    Ó    ð1oÙà88:DØ-<×-AÑ-AÔBUÐW[Ð]eÓ-fÑ*G[ (ð ¸Ö"R¨fÁ6È&Å>¢6Ò"RÑRÐð$/ò 1Ù/Õ*ØKK Õ0ð 1ò÷1ô Ð 2Ó3Ðä
LLÐ<Ð>PÔQØÐùò#S÷1ð1ús*Â'3EÃ EÃ(EÃ,EÃ?EÅEÅEc    óÖddl}ddl}ddlm}ddlm}|j d|«g}g}    t|«||jvr|||fSt!|j|dd«xsg}    |    s|||fS|j#|«|j d||    «|j%|    |dz«D]+\}
}}|s|j#|«|j#|«-|||fS#t$r}|dvr`ddl    m}dj|t|«|««j«}|jd|d|d    |«|d
k(rd}|||fcYd}~S|dk(rtd |d«|Yd}~,d}~wwxYw)Nr)Úformat_exception_only)rIz-collect_submodules - scanning (sub)package %s)rÁr½r4z"Failed to collect submodules for 'z' because importing 'z
' raised: r½rÀrÂzUnable to load subpackage 'z'.Ú__path__z@collect_submodules - scanning (sub)package %s in location(s): %srx)r8ÚpkgutilÚ    tracebackrÑÚPyInstaller.utils.hooksrIrJrfrgÚPyInstaller.logrÚtyperr³rr;rprGÚiter_modules)rrÉr8rÓrÑrIr;rÍÚexÚpathsÚimporterÚispkgs            r$rÆrÆsÛÛÝ/å.à
LLÐ@À$ÔGàGØKðNÜ4Ôð3;;ÑØ XÐ-Ð-ô CKK Ñ% z°4Ó8Ò>¸BEÙØ XÐ-Ð-ðNN4ÔðLLÐSÐUYÐ[`ÔaØ!(×!5Ñ!5°e¸TÀC¹ZÓ!Hò%Ñ$ÙØNN4Õ à×ÑtÕ$ð    %ðK Ð)Ð)øôAò
NàÐ,Ñ,Ý.ØÑ.¬t°B«x¸Ó<Ó=×CÑCÓEBØNNÐ?À¸vÐEZÐ[_ÐZ`Ð`jÐkmÐjnÐoÔpØ;Ò&Ø#ØK¨Ð1Õ1Ø Ò  ÜÐ ;¸D¸6ÀÐDÓEÈ2ÐMõ!ûð
Nús$¬CÃ    E(Ã$AE#ÅE(ÅE#Å#E(có8|j|dz«xs||k(S)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'))``
    rx)rT)rÚ mod_or_submods  r$Úis_module_or_submodulerß½s"ð??=¨3Ñ.Ó/ÒH°4¸=Ñ3HÐHr&)ú*.dllz*.dylibzlib*.soc    ótjd|z«t|t«st    d«t|«stj d|«gSt|«}g}|D]}t||«}|D]}t|«j|«}|D]b}    |r|}
n|    jj|«}
tjd|    d|
«|jt|    «t|
«f«d|S)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 %sr¿zZcollect_dynamic_libs - skipping library collection for module '%s' as it is not a package.ú z, )rIrJrÃr¢rr¥r³r«r°rÚrglobÚparentÚrelative_torG)rÚdestdirÚsearch_patternsÚpkg_dirsÚdylibsr´rµÚpatternÚfilesÚsourceÚdests           r$Úcollect_dynamic_libsrîÓsüôLLÐ6¸Ñ@ÔAôgsÔ#ÜÐ/Ó0Ð0ôgÔÜØhÐjqô    
ð    ä$ WÓ-HØ FØò8Ü$ W¨gÓ6à&ò    8GÜM×'Ñ'¨Ó0EØò     8áà"Dð"==×4Ñ4°XÓ>DÜª&±$Ð7Ô8Ø  s 6{¬C°«IÐ6Õ7ñ     8ñ    8ð8ð Mr&cóx tjd|z«t|t«st    d«t|«stj d|«gS|rt|«ng}t|«}|s%|tjDcgc]}d|z    c}z }n)|tjDcgc]}|dvsd|zc}z }|jd«|rt|«ndg}t|«} fd}g}    t|«}
|
D]}t« t||«}|r tj j#||«}||||d«||||d    «|     Dcgc]1}t|«t|j$j'|««f3c}z }    tjd
|    «|    Scc}wcc}wcc}w)aÐ
 
    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 <https://docs.python.org/3/library/pathlib.html#pathlib.Path.glob>`_
        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 %sr¿zUcollect_data_files - skipping data collection for module '%s' as it is not a package.ú**/*>ú.pyú.pycz**/__pycache__/*.pycc    ó8t|«D]\}}t|«j|«D]i}|j«r3||ks|j    t|dzj |«««F|rj|«nj|«ky)Nrð)    Ú    enumeraterÚglobÚis_dirrGr¢råÚaddÚdiscard)r´ÚcludesÚ    clude_lenÚ
is_includeÚiÚcÚgÚsourcess       r$Úclude_walkerz(collect_data_files.<locals>.clude_walkerHsøôfÓ%ò        IDAqÜ']×'Ñ'¨Ó*ò IØ88:à9}à  ¤c¨1¨v©:×*BÑ*BÀ7Ó*KÓ&LÕMñ'1GKK N°g·o±oÀaÓ6Hùñ Iñ        Ir&TFz$collect_data_files - Found files: %s)rIrJrÃr¢rr¥r³r>rUr    ÚALL_SUFFIXESrGr«r:r°rrPrrärå)rÚinclude_py_filesÚsubdirÚexcludesÚincludesÚexcludes_lenÚsÚincludes_lenrÚdatasrèr´rµrÿs             @r$Úcollect_data_filesr
ýs©øôTLLÐ/°'Ñ9Ô:ôgsÔ#ÜÐ/Ó0Ð0ôgÔÜÐnÐpwÔxØ    ñ"*tH~¨rHäx=LñØ¬×)<Ñ)<Ö= AVaZÒ=Ñ=ð    ¬×)<Ñ)<ÖY AÀÈÒ@XVaZÒYÑYð OOÐ*Ô+ñ"*tH~°¨xHÜx=Lô
Ið, Eä$ WÓ-HØòRÜ%ä$ W¨gÓ6ÙÜggll 7¨FÓ3Gñ    Wh¨°dÔ;ÙWh¨°eÔ<ð    ÈÖQÀA3q63qxx×3Ñ3°HÓ=Ó>Ò?ÒQÑQðRôLLÐ7¸Ô?ØLùòo>ùòZùòbRsÂF-Â,    F2Â6F2Å6F7cóÔt|t«std«g}tj|«D]²\}}}|D]§}tj
j |«d}|s    |tvs0tj
j||«}    tt|«j|««}
| tj
j||
«}
|j|    |
f«©´|S)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²)rÃr¢rrÚwalkrPr`ÚPY_IGNORE_EXTENSIONSrrrårG)rPrærr    ÚdirpathÚdirnamesrëÚfÚ    extensionrìrís           r$Úcollect_system_data_filesrssÐôdCÔ ÜÐ,Ó-Ð-ð EÜ$&§G¡G¨D£Mò    -Ñ 5Øò    -AÜ×(Ñ(¨Ó+¨AÑ.IÙ IÔ5IÒ$Iä g¨qÓ1Ü4 =×4Ñ4°TÓ:Ó;ØÐ&Ü77<<¨°Ó6DØf d^Õ,ñ    -ð    -ðLr&códdlm}||g«}t«}g}|r¼|j«}||vrt    j
|«}t |d«stdt|«d|d«|j}t|t«s    |jj|jjz}|j«r<|jj!d«r!tdt#|«d    |d
|d|d    «td|d t|«d«|j%«rk|jdk(rO|jjj!d«r*t'j(j*|j,dd}    n2|j}    n%|j«rd}    ntd|d|d«|jjdk(rD|jjjdk(r!t&j(j+dd|    «}    |j/t#|«t#|    «f«|s|S|j1|«|j2xsgD
cgc]!}
t4j6j9|
«#}}
|D
cgc]5}
|
j:|
j:j=«s*|
j7}}
||z }|r¼|S#t$r|j}Y;wxYwcc}
wcc}
w)aL
    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 rxzEGG-INFOéþÿÿÿNzDistribution metadata path z is neither file nor directory!Ú_vendorÚ
setuptools)Úcollectionsrr:rÅr ÚdistributionÚhasattrÚRuntimeErrorr×rrÃrrärrgÚis_filerZr¢rörrPrÚpartsrGr÷ÚrequiresrrrÚmarkerÚevaluate)Úpackage_nameÚ    recursiverrËÚdoneÚoutÚdistÚsrc_pathÚ
src_parentÚ    dest_pathÚreqrs            r$Ú copy_metadatar*sáõ`"á,Ó DÜ5DØ
Câ
ØxxzØ4ÑØä!×.Ñ.¨|Ó<ô
tWÔ%ÜØ0´°d³°¸EÀ,ÀÐOoÐpóð ð::ô(¤DÔ)ð
 -Ø%__×3Ñ3°h·o±o×6JÑ6JÑJ
ð×!Ñ!Ô#¨
¯©×(@Ñ(@ÀÔ(HÜ"Ø8¼¸X»Ð8IðJaØamÐ`pðq'ð(4 nð5%ð&2 Nð3xð
xóðô#Ø8¸¸ÐDcÔdhÐiqÓdrÐcsÐstÐuóðð??Ôð}} 
Ò*¨x¯©×/CÑ/C×/LÑ/LÈVÔ/TÜGGLL¨(¯.©.¸¸Ð*=Ð>    à$MM    Ø × Ñ Ô ðIäØ-¨h¨\¸¸|¸nÐLkÐlóð ð??×Ñ 9Ò,°·±×1GÑ1G×1LÑ1LÐP\Ò1\Ü \°9¸iÓHIà

CM¤3 y£>Ð2Ô3áØJØÔð
LPÏ=É=ÒK^Ð\^Ö_ÀC    ×.Ñ.×:Ñ:¸3Õ?Ð_Ð_Ø,8Öh S¸C¿J¹JÐ<NÐRU×R\ÑR\×ReÑReÕRgÐhÐhàÑókðnJøôwò -Ø%__
ð -üòl`ùÚhs$Â -KÉ*&K9Ê+K>ËK>ËK6Ë5K6có¶    tj|«}|jd«}||j«Sy#tj$rYnwxYw|}tj
«}|j |«}|xsgD]V}    tj|«}|jd«}||j«cS?#tj$rYTwxYwy)aè
    Try to find which package manager installed the specified distribution (e.g., pip, conda, rpm) by reading INSTALLER
    file from distribution's metadata.
 
    If the specified distribution does not exist, fall back to treating the passed name as importable package/module
    name, and attempt to look up its associated distribution name; this matches the behavior of implementation found
    in older PyInstaller versions (<= v6.12.0).
 
    :param dist_name: Name of distribution to look up
    :return: Name of package manager or None
 
    .. versionchanged:: 6.13
        The passed name is now first treated as a distribution name (direct look-up), and only if that fails, it is
        treated as importable package/module name.
    Ú    INSTALLERN)r rÚ    read_textrrÚpackages_distributionsr)Ú    dist_namer%Úinstaller_textr?Úpkg_to_distÚ
dist_namess      r$Ú get_installerr3sìð$     Ü!×.Ñ.¨yÓ9Ø¨Ó4ØÐ%Ø!×'Ñ'Ó)Ð)ðøÜ×2Ñ2ò Ùð úðKÜ$×;Ñ;Ó=KØ Ó-Jð Ò% 2ò        ð    Ü%×2Ñ2°9Ó=DØ!^^¨KÓ8NØÐ)Ø%×+Ñ+Ó-Ò-ð*øä!×6Ñ6ò    ñ ð    úð     ðs!7;»AÁAÂ7CÃCÃCcóyr¸r¹rºs r$r»r»Ur¼r&cót||||¬«}t|«}t|||¬«}tj«}    t|    j |g««}
|
D]}    |t|«z }|||fS#t$rY$wxYw)aÀ
    Collect everything for a given package name.
 
    Arguments:
        package_name:
            An ``import``-able package name.
        include_py_files:
            Forwarded to :func:`collect_data_files`.
        filter_submodules:
            Forwarded to :func:`collect_submodules`.
        exclude_datas:
            Forwarded to :func:`collect_data_files`.
        include_datas:
            Forwarded to :func:`collect_data_files`.
        on_error:
            Forwarded onto :func:`collect_submodules`.
 
    Returns:
        tuple: A ``(datas, binaries, hiddenimports)`` triplet containing:
 
        - All data files, raw Python files (if **include_py_files**), and distribution metadata directories (if
          applicable).
        - All dynamic libraries as returned by :func:`collect_dynamic_libs`.
        - All submodules of **package_name**.
 
    Typical use::
 
        datas, binaries, hiddenimports = collect_all('my_package_name')
    )rr)rÉrÈ)    r
rîrÏr r.r:rr*rg)r!rÚfilter_submodulesÚ exclude_datasÚ include_datasrÉr    ÚbinariesÚ hiddenimportsr1r2r/s            r$Úcollect_allr;RsôJ |Ð-=È Ð`mÔnEÜ# LÓ1HÜ& |¸hÐO`ÔaMô%×;Ñ;Ó=KÜ[__ \°2Ó6Ó7JØò    ð    Ø] 9Ó-Ñ-Eðð(MÐ)Ð)øôò    Ùð    úsÁA3Á3    A?Á>A?cóÂg}g}tj|¬«D]?}|t|jj«z }|j|j«A||fS)ai
    Collect modules and metadata for all exporters of a given entry point.
 
    Args:
        name:
            The name of the entry point. Check the documentation for the library that uses the entry point to find
            its name.
    Returns:
        A ``(datas, hiddenimports)`` pair that should be assigned to the ``datas`` and ``hiddenimports``, respectively.
 
    For libraries, such as ``pytest`` or ``keyring``, that rely on plugins to extend their behaviour.
 
    Examples:
        Pytest uses an entry point called ``'pytest11'`` for its extensions.
        To collect all those extensions use::
 
            datas, hiddenimports = collect_entry_point("pytest11")
 
        These values may be used in a hook or added to the ``datas`` and ``hiddenimports`` arguments in the ``.spec``
        file. See :ref:`using spec files`.
 
    .. versionadded:: 4.3
    )Úgroup)r Úentry_pointsr*r%rrGrr)rr    ÚimportsÚentry_points    r$Úcollect_entry_pointrAsað0 EØGÜ)×6Ñ6¸TÔBò+Ø {×/Ñ/×4Ñ4Ó5Ñ5Ø{×)Ñ)Õ*ð+ð'>Ðr&có\|jj}d}||vr|||vr|||}|S)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?ÚkeyÚconfigÚvalues     r$Úget_hook_configrI©sBð8× Ñ × *Ñ *FØEØfÑ ¨¨{Ñ(;Ñ!;Ø{Ñ# CÑ(ØLr&có| |D]}tj||«sny||D]}tj||«syy)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_listrês    r$Úinclude_or_exclude_filerNÌsZð0ÐØ#ò    GÜx¨Õ1Ùð    ðàÐØ#ò    GÜx¨Õ1Ùð    ðr&c
ó|xsg}|xsg}||dz}tjs||fSt|«\}}t|«}||z}|j    «s||fS||jd«Dcgc]1}t |«t |jj|««f3c}z }||jd«Dcgc]1}t |«t |jj|««f3c}z }||fScc}wcc}w)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.libsràz.load[-_]order*)    r    Úis_winr¶rrörõr¢rärå)    r!Úlibdir_namer    r9rµr´Úlibs_dirÚdll_fileÚload_order_files             r$Ú!collect_delvewheel_libs_directoryrUósðF KREØ~2HàÐØ" WÑ,ô==ØhÐô*¨,Ó7ÑHgÜH~HØ+Ñ%Hà??ÔØhÐð Ð]e×]jÑ]jÐkrÓ]sÖtÐQY#h-¤ X§_¡_×%@Ñ%@ÀÓ%JÓ!KÒLÒtÑtHð
 
Ø%-§]¡]Ð3DÓ%EöGØ!ô?Ó#¤S¨×)?Ñ)?×)KÑ)KÈHÓ)UÓ%VÒWòGñGEð(?Ðùòuùò
GsÁ.6C<Â=6D)Úconda)ÚCONDA_META_DIRz¨Assuming 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+r¢r¡)r4)rNr¢)rVr¢rWr¢)rVr¢r[r¢)rar¢)r?r¢rqr¢r©)rr¢)NN)rr¢rÚNonerrX)r¯r¢rr¢)rr¢rÈzCallable[[str], bool]rÉr¢)rr¢rÞr¢)rr¢ræz
str | Nonerçr>)FNNN)
rr¢rrrústr | os.PathLike | Nonerúlist | NonerrZ)NF)rPr¢rærYrr)F)r!r¢r"r)r/r¢)r!r¢rrr6rr7rZr8rZrÉr¢)rr¢)rErr?r¢rFr¢)rar¢rLrZrMrZ)NNN)KÚ
__future__rrrr)rKÚpathlibrrrÚtypingrÚpackaging.requirementsrÚPyInstallerrr    r
ÚloggingÚPyInstaller.depend.imphookapirrÚPyInstaller.compatr Ú    getLoggerÚ__name__rIr:rr Úhook_variablesr%r,r0r2r6rjrArRrXr\rcrlrvrrrrr¥r«r°r¶rÏrÆrßÚPY_DYLIB_PATTERNSrîr
rr*r3r;rArIrNrUÚ is_pure_condarÕrVÚ conda_supportÚis_condaÚPyInstaller.utils.hooks.condarWÚ_tmpr³r¹r&r$ú<module>rlsoðõ#ãÛ    ÛÛÝÝÝãç(Ý&Ý6Ý Ý1à    ×    Ñ    8Ó    $ñ6×.Ñ.Ó/Ððó7ó8Aó<ó(=óð2
×ÑòDóðDô2ó6ó    ó
)óóF#kóL>òB9ó&+LðdØð$+Øð$+à ð$+ðó$+óN7óDóBEóñ8%6ØðPØ ðPà!ðPðóPòh/*ódIòÐð>BÐ[lô'ðX#Ø'+Ø Ø ðsØ ðsàðsð %ðsðð    sð
ósôlô6Mó`1ðl"Ù"3Ø!%Ø!%Øð 4*Øð4*àð4*ð ð4*ðð    4*ð
ð4*ðó 4*ónó@ ðJ!%Ø $ð$Øð$àð$ðó$óNAðH
×ÒÞ>Ø__ÝDØ
NNð    HØIMôñ     ð r&