File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/via_global_ref.tar
Back
__pycache__/_virtualenv.cpython-310.pyc 0000644 00000005305 15030253017 0014012 0 ustar 00 o }h[ � @ sZ d Z ddlmZ ddlZddlZej�e�Zdd� Z dZ G dd� d�Z ej � de � � dS ) z?Patches that are applied at runtime to the virtual environment.� )� annotationsNc s | j j� � fdd�}|| j _dS )a Distutils allows user to configure some arguments via a configuration file: https://docs.python.org/3/install/index.html#distutils-configuration-files. Some of this arguments though don't make sense in context of the virtual environment files, let's fix them up. c sj � | g|�R i |��}| � d�}d|v r ttj�tj�f|d< dD ]}d|� �}||v r2|�|d � q!|S )N�install�prefix)�purelib�platlib�headers�scripts�data�install_)�get_option_dict�VIRTUALENV_PATCH_FILE�os�path�abspath�sysr �pop)�self�args�kwargs�resultr �base�key��old_parse_config_files� �W/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/_virtualenv.py�parse_config_files s �z&patch_dist.<locals>.parse_config_filesN)� Distributionr )�distr r r r � patch_dist s r )zdistutils.distzsetuptools.distc @ s: e Zd ZdZdZg Zd dd�Zedd� �Zedd� �Z dS ) �_FinderzGA meta path finder that allows patching the imported distutils modules.Nc C s2 |t v r�| jd u r�t| j�dkr dd l}|�� }| j�|� ddlm} ddl m } | jd �` || _zO|||�}|d ur~t |j d�} | rGdnd} t |j | �} | rT| jn| j} | | urqz t|j | || | �� W n typ Y nw |W d | _W d � S W d | _nd | _w W d � d S 1 s�w Y d S )Nr )�partial)� find_spec� exec_module� load_module)�_DISTUTILS_PATCH�fullname�len�lock� threading�Lock�append� functoolsr! �importlib.utilr" �hasattr�loader�getattrr# r$ �setattr�AttributeError) r r& r �targetr) r( r! r" �spec� is_new_api� func_name�old�funcr r r r" 4 s> �� ��z_Finder.find_specc C s" | |� |j tv rt|� d S d S �N��__name__r% r )r7 �moduler r r r# Y s �z_Finder.exec_modulec C s | |�}|j tv r t|� |S r9 r: )r7 �namer< r r r r$ _ s z_Finder.load_moduler9 ) r; � __module__� __qualname__�__doc__r& r( r" � staticmethodr# r$ r r r r r * s % r )r@ � __future__r r r r �join�__file__r r r% r � meta_path�insertr r r r �<module> s = __pycache__/store.cpython-310.pyc 0000644 00000001535 15030253017 0012611 0 ustar 00 o }h� � @ s4 d dl mZ d dlmZ dd� Zdd� ZddgZdS )� )� annotations)�Pathc C s t |�rd| _| S )NzFWindows Store Python does not support virtual environments via symlink)�is_store_python� symlink_error)�meta� interpreter� r �Q/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/store.py�handle_store_python s r c C sL t | j�j}t|�dko%|d dko%|d dko%|d �d�o%|d �d �S ) N� ���� Microsoft���� WindowsApps���z"PythonSoftwareFoundation.Python.3.����python)r �system_executable�parts�len� startswith)r r r r r r s � � � �r N)� __future__r �pathlibr r r �__all__r r r r �<module> s � __pycache__/__init__.cpython-310.pyc 0000644 00000000261 15030253017 0013207 0 ustar 00 o }h � @ s d S )N� r r r �T/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/__init__.py�<module> s __pycache__/venv.cpython-310.pyc 0000644 00000007662 15030253017 0012442 0 ustar 00 o }hh � @ s� d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dlm Z d dl m Z d dl m Z d d lmZmZ d d lmZ d d lmZ e�e�ZG d d� de�ZdgZdS )� )� annotationsN)�copy)�handle_store_python)� PythonInfo)�ProcessCallFailedError)� ensure_dir)�run_cmd� )�ViaGlobalRefApi�ViaGlobalRefMeta)�CPython3macOsBrew)� Pypy3Windowsc sv e Zd Zd� fdd� Z� fdd�Zedd� �Z� fd d �Zd d � Zd d� Z dd� Z dd� Z � fdd�Z dd� Z � ZS )�Venv�return�Nonec s> |j | _ t� �||� t�� }||u o|j|jk| _d | _d S �N) �describe�super�__init__r �current� executable�system_executable� can_be_inline�_context)�self�options� interpreterr �� __class__� �P/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/venv.pyr s z Venv.__init__c s& t � �� | jrd| jjjfg S g S )Nr )r �_argsr r �__name__)r r r r r! s &z Venv._argsc C s< |j r t�|�r t�|�S t� }|jdkrt||�}|S d S )N�win32)�has_venvr � can_describe� setup_metar �platformr )�clsr �metar r r � can_create s zVenv.can_createc sB | j r| �� n| �� | jD ]}t|� qt� �� | �� d S r )r � create_inline�create_via_sub_process�libsr r �create�!executables_for_win_pypy_less_v37)r �libr r r r. ) s z Venv.createc C sB | j }t|t�r|jr |�| j�D ] }|�|| j� qdS dS dS )z� PyPy <= 3.6 (v7.3.3) for Windows contains only pypy3.exe and pypy3w.exe Venv does not handle non-existing exe sources, e.g. python.exe, so this patch does it. N)r � isinstancer �less_v37� executablesr �run�symlinks)r �creator�exer r r r/ 3 s �z&Venv.executables_for_win_pypy_less_v37c C s4 ddl m} || jd| jdd�}|�t| j�� d S )Nr )� EnvBuilderF)�system_site_packages�clearr5 �with_pip)�venvr8 �enable_system_site_packager5 r. �str�dest)r r8 �builderr r r r+ > s �zVenv.create_inlinec C sB | � � }t�dd�|�� t|�\}}}|dkr t||||��d S )Nz)using host built-in venv to create via %s� r )�get_host_create_cmd�LOGGER�info�joinr r )r �cmd�code�out�errr r r r, I s �zVenv.create_via_sub_processc C sB | j jdddg}| jr|�d� |�| jrdndt| j�f� |S )Nz-mr< z --without-pipz--system-site-packagesz --symlinksz--copies)r r r= �append�extendr5 r> r? )r rF r r r rB P s zVenv.get_host_create_cmdc s( t | j�� �}t� �� | j�|� d S r )r � pyenv_cfg�refreshr � set_pyenv_cfg�update)r � venv_contentr r r rN W s zVenv.set_pyenv_cfgc C sH t �| d�}|d ur t||�r t||�}t|�r |dkr |S t �| |�S )Nr �script)�object�__getattribute__�hasattr�getattr�callable)r �itemr �elementr r r rS ] s zVenv.__getattribute__)r r )r" � __module__� __qualname__r r! � classmethodr* r. r/ r+ r, rB rN rS � __classcell__r r r r r s r )� __future__r �loggingr �&virtualenv.create.via_global_ref.storer � virtualenv.discovery.py_infor �virtualenv.util.errorr �virtualenv.util.pathr �virtualenv.util.subprocessr �apir r �builtin.cpython.mac_osr �builtin.pypy.pypy3r � getLoggerr" rC r �__all__r r r r �<module> s T� __pycache__/api.cpython-310.pyc 0000644 00000010562 15030253017 0012226 0 ustar 00 o }h� � @ s� d dl mZ d dlZd dlZd dlmZ d dlmZ d dlm Z m Z d dl m Z e� e�ZG dd� de �ZG d d � d e e�Zd dgZdS ) � )� annotationsN)�ABC)�Path)�Creator� CreatorMeta)�fs_supports_symlinkc s6 e Zd Zd � fdd� Zedd� �Zedd� �Z� ZS ) �ViaGlobalRefMeta�return�Nonec s* t � �� d | _d | _t� sd| _d S d S )Nz(the filesystem does not supports symlink)�super�__init__� copy_error� symlink_errorr ��self�� __class__� �O/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/api.pyr s �zViaGlobalRefMeta.__init__c C � | j S �N)r r r r r �can_copy � zViaGlobalRefMeta.can_copyc C r r )r r r r r � can_symlink r z ViaGlobalRefMeta.can_symlink�r r )�__name__� __module__� __qualname__r �propertyr r � __classcell__r r r r r s r c sj e Zd Zd� fdd� Zedd� �Ze� fdd��Zd d � Zd d � Z d d� Z � fdd�Z � fdd�Z � Z S )�ViaGlobalRefApir r c s& t � �||� | �|�| _|j| _d S r )r r �_should_symlink�symlinks� system_site�enable_system_site_package)r �options� interpreterr r r r s zViaGlobalRefApi.__init__c C s� t | dd�t | dd�}}| �d�| �d�}}dD ]+}||kr"|nd }||kr*|nd }|du r7|du r7 dS |du r> dS |du rE dS qdS )N�copiesFr" )�clizenv var�file�defaultT)�getattr� get_source)r% r' r" �copy_src�sym_src�level�s_opt�c_optr r r r! % s �z ViaGlobalRefApi._should_symlinkc s� t � �||||� |jdddddd� |js |js d}t|��|�� }|jr0|jdd dd d d� |jrB|jd d |j dddd� d S d S )Nz--system-site-packagesF� store_truer# zCgive the virtual environment access to the system site-packages dir)r* �action�dest�helpz(neither symlink or copy method supportedz --symlinksTr" zZtry to use symlinks rather than copies, when symlinks are not the default for the platformz--copiesz --always-copyr' z[try to use copies rather than symlinks, even when symlinks are the default for the platform)r �add_parser_arguments� add_argumentr r � RuntimeError� add_mutually_exclusive_group)�cls�parserr& �meta�app_data�msg�groupr r r r6 6 s< � � ��z$ViaGlobalRefApi.add_parser_argumentsc C s | � � d S r )� install_patchr r r r �createV s zViaGlobalRefApi.createc C s\ | � � }|r,| jd }t�d|� |jddd� | jd }t�d|� |j|dd� d S d S )Nz_virtualenv.pthz%create virtualenv import hook file %szimport _virtualenv�utf-8��encoding�_virtualenv.pyz create %s)�env_patch_text�purelib�LOGGER�debug� write_text)r �text�pth� dest_pathr r r r@ Y s �z ViaGlobalRefApi.install_patchc C sl | j �tt�jd ��!}|jdd�}|�dttj � t | j �t | j ����W d � S 1 s/w Y dS )zJPatch the distutils package to not be derailed by its configuration files.rE rB rC z"__SCRIPT_DIR__"N)r= �ensure_extractedr �__file__�parent� read_text�replace�repr�os�path�relpath�str� script_dirrG )r � resolved_pathrK r r r rF c s $$�z ViaGlobalRefApi.env_patch_textc s g t � �� �d| jf�S )N�global)r �_argsr$ r r r r r[ i s zViaGlobalRefApi._argsc s" t � �� | jr dnd| jd< d S )N�true�falsez include-system-site-packages)r � set_pyenv_cfgr$ � pyenv_cfgr r r r r^ l s z ViaGlobalRefApi.set_pyenv_cfgr )r r r r � staticmethodr! � classmethodr6 rA r@ rF r[ r^ r r r r r r s r )� __future__r �loggingrT �abcr �pathlibr �virtualenv.create.creatorr r �virtualenv.infor � getLoggerr rH r r �__all__r r r r �<module> s S� builtin/ref.py 0000644 00000012471 15030253017 0007341 0 ustar 00 """ Virtual environments in the traditional sense are built as reference to the host python. This file allows declarative references to elements on the file system, allowing our system to automatically detect what modes it can support given the constraints: e.g. can the file system symlink, can the files be read, executed, etc. """ # noqa: D205 from __future__ import annotations import os from abc import ABC, abstractmethod from collections import OrderedDict from stat import S_IXGRP, S_IXOTH, S_IXUSR from virtualenv.info import fs_is_case_sensitive, fs_supports_symlink from virtualenv.util.path import copy, make_exe, symlink class RefMust: NA = "NA" COPY = "copy" SYMLINK = "symlink" class RefWhen: ANY = "ANY" COPY = "copy" SYMLINK = "symlink" class PathRef(ABC): """Base class that checks if a file reference can be symlink/copied.""" FS_SUPPORTS_SYMLINK = fs_supports_symlink() FS_CASE_SENSITIVE = fs_is_case_sensitive() def __init__(self, src, must=RefMust.NA, when=RefWhen.ANY) -> None: self.must = must self.when = when self.src = src try: self.exists = src.exists() except OSError: self.exists = False self._can_read = None if self.exists else False self._can_copy = None if self.exists else False self._can_symlink = None if self.exists else False def __repr__(self) -> str: return f"{self.__class__.__name__}(src={self.src})" @property def can_read(self): if self._can_read is None: if self.src.is_file(): try: with self.src.open("rb"): self._can_read = True except OSError: self._can_read = False else: self._can_read = os.access(str(self.src), os.R_OK) return self._can_read @property def can_copy(self): if self._can_copy is None: if self.must == RefMust.SYMLINK: self._can_copy = self.can_symlink else: self._can_copy = self.can_read return self._can_copy @property def can_symlink(self): if self._can_symlink is None: if self.must == RefMust.COPY: self._can_symlink = self.can_copy else: self._can_symlink = self.FS_SUPPORTS_SYMLINK and self.can_read return self._can_symlink @abstractmethod def run(self, creator, symlinks): raise NotImplementedError def method(self, symlinks): if self.must == RefMust.SYMLINK: return symlink if self.must == RefMust.COPY: return copy return symlink if symlinks else copy class ExePathRef(PathRef, ABC): """Base class that checks if a executable can be references via symlink/copy.""" def __init__(self, src, must=RefMust.NA, when=RefWhen.ANY) -> None: super().__init__(src, must, when) self._can_run = None @property def can_symlink(self): if self.FS_SUPPORTS_SYMLINK: return self.can_run return False @property def can_run(self): if self._can_run is None: mode = self.src.stat().st_mode for key in [S_IXUSR, S_IXGRP, S_IXOTH]: if mode & key: self._can_run = True break else: self._can_run = False return self._can_run class PathRefToDest(PathRef): """Link a path on the file system.""" def __init__(self, src, dest, must=RefMust.NA, when=RefWhen.ANY) -> None: super().__init__(src, must, when) self.dest = dest def run(self, creator, symlinks): dest = self.dest(creator, self.src) method = self.method(symlinks) dest_iterable = dest if isinstance(dest, list) else (dest,) if not dest.parent.exists(): dest.parent.mkdir(parents=True, exist_ok=True) for dst in dest_iterable: method(self.src, dst) class ExePathRefToDest(PathRefToDest, ExePathRef): """Link a exe path on the file system.""" def __init__(self, src, targets, dest, must=RefMust.NA, when=RefWhen.ANY) -> None: ExePathRef.__init__(self, src, must, when) PathRefToDest.__init__(self, src, dest, must, when) if not self.FS_CASE_SENSITIVE: targets = list(OrderedDict((i.lower(), None) for i in targets).keys()) self.base = targets[0] self.aliases = targets[1:] self.dest = dest def run(self, creator, symlinks): bin_dir = self.dest(creator, self.src).parent dest = bin_dir / self.base method = self.method(symlinks) method(self.src, dest) if not symlinks: make_exe(dest) for extra in self.aliases: link_file = bin_dir / extra if link_file.exists(): link_file.unlink() if symlinks: link_file.symlink_to(self.base) else: copy(self.src, link_file) if not symlinks: make_exe(link_file) def __repr__(self) -> str: return f"{self.__class__.__name__}(src={self.src}, alias={self.aliases})" __all__ = [ "ExePathRef", "ExePathRefToDest", "PathRef", "PathRefToDest", "RefMust", "RefWhen", ] builtin/cpython/cpython3.py 0000644 00000011265 15030253017 0012020 0 ustar 00 from __future__ import annotations import abc import fnmatch from itertools import chain from operator import methodcaller as method from pathlib import Path from textwrap import dedent from virtualenv.create.describe import Python3Supports from virtualenv.create.via_global_ref.builtin.ref import PathRefToDest from virtualenv.create.via_global_ref.store import is_store_python from .common import CPython, CPythonPosix, CPythonWindows, is_mac_os_framework, is_macos_brew class CPython3(CPython, Python3Supports, abc.ABC): """CPython 3 or later.""" class CPython3Posix(CPythonPosix, CPython3): @classmethod def can_describe(cls, interpreter): return ( is_mac_os_framework(interpreter) is False and is_macos_brew(interpreter) is False and super().can_describe(interpreter) ) def env_patch_text(self): text = super().env_patch_text() if self.pyvenv_launch_patch_active(self.interpreter): text += dedent( """ # for https://github.com/python/cpython/pull/9516, see https://github.com/pypa/virtualenv/issues/1704 import os if "__PYVENV_LAUNCHER__" in os.environ: del os.environ["__PYVENV_LAUNCHER__"] """, ) return text @classmethod def pyvenv_launch_patch_active(cls, interpreter): ver = interpreter.version_info return interpreter.platform == "darwin" and ((3, 7, 8) > ver >= (3, 7) or (3, 8, 3) > ver >= (3, 8)) class CPython3Windows(CPythonWindows, CPython3): """CPython 3 on Windows.""" @classmethod def setup_meta(cls, interpreter): if is_store_python(interpreter): # store python is not supported here return None return super().setup_meta(interpreter) @classmethod def sources(cls, interpreter): if cls.has_shim(interpreter): refs = cls.executables(interpreter) else: refs = chain( cls.executables(interpreter), cls.dll_and_pyd(interpreter), cls.python_zip(interpreter), ) yield from refs @classmethod def executables(cls, interpreter): return super().sources(interpreter) @classmethod def has_shim(cls, interpreter): return interpreter.version_info.minor >= 7 and cls.shim(interpreter) is not None # noqa: PLR2004 @classmethod def shim(cls, interpreter): shim = Path(interpreter.system_stdlib) / "venv" / "scripts" / "nt" / "python.exe" if shim.exists(): return shim return None @classmethod def host_python(cls, interpreter): if cls.has_shim(interpreter): # starting with CPython 3.7 Windows ships with a venvlauncher.exe that avoids the need for dll/pyd copies # it also means the wrapper must be copied to avoid bugs such as https://bugs.python.org/issue42013 return cls.shim(interpreter) return super().host_python(interpreter) @classmethod def dll_and_pyd(cls, interpreter): folders = [Path(interpreter.system_executable).parent] # May be missing on some Python hosts. # See https://github.com/pypa/virtualenv/issues/2368 dll_folder = Path(interpreter.system_prefix) / "DLLs" if dll_folder.is_dir(): folders.append(dll_folder) for folder in folders: for file in folder.iterdir(): if file.suffix in {".pyd", ".dll"}: yield PathRefToDest(file, cls.to_bin) @classmethod def python_zip(cls, interpreter): """ "python{VERSION}.zip" contains compiled *.pyc std lib packages, where "VERSION" is `py_version_nodot` var from the `sysconfig` module. :see: https://docs.python.org/3/using/windows.html#the-embeddable-package :see: `discovery.py_info.PythonInfo` class (interpreter). :see: `python -m sysconfig` output. :note: The embeddable Python distribution for Windows includes "python{VERSION}.zip" and "python{VERSION}._pth" files. User can move/rename *zip* file and edit `sys.path` by editing *_pth* file. Here the `pattern` is used only for the default *zip* file name! """ # noqa: D205 pattern = f"*python{interpreter.version_nodot}.zip" matches = fnmatch.filter(interpreter.path, pattern) matched_paths = map(Path, matches) existing_paths = filter(method("exists"), matched_paths) path = next(existing_paths, None) if path is not None: yield PathRefToDest(path, cls.to_bin) __all__ = [ "CPython3", "CPython3Posix", "CPython3Windows", ] builtin/cpython/__pycache__/__init__.cpython-310.pyc 0000644 00000000301 15030253017 0016334 0 ustar 00 o }h � @ s d S )N� r r r �d/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/cpython/__init__.py�<module> s builtin/cpython/__pycache__/mac_os.cpython-310.pyc 0000644 00000027063 15030253017 0016054 0 ustar 00 o }h�- � @ s� d Z ddlmZ ddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z ddlmZmZmZ ddlmZ d d lmZmZmZmZ d d lmZ e�e �Z G d d � d ee�Z G dd� de ee�Z dd� Z dd� Z!G dd� dee�Z"g d�Z#dS )z;The Apple Framework builds require their own customization.� )� annotationsN)�ABC�abstractmethod)�Path)�dedent)�ExePathRefToDest� PathRefToDest�RefMust)�BuiltinViaGlobalRefMeta� )�CPython� CPythonPosix�is_mac_os_framework� is_macos_brew)�CPython3c sT e Zd Ze� fdd��Z� fdd�Ze� fdd��Zedd� �Zed d � �Z � Z S ) �CPythonmacOsFrameworkc � t |�o t� �|�S �N)r �super� can_describe��cls� interpreter�� __class__� �b/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/cpython/mac_os.pyr � z"CPythonmacOsFramework.can_describec s� t � �� � �� }� �� }� jD ]7}t|t�rG|jtj ks � j sG� j |j g}� j s7|� � fdd�|jD �� |D ] }tt|�||� jj� q9qd S )Nc 3 s � | ]}� j | V qd S r )�bin_dir)�.0�a��selfr r � <genexpr>) s � z/CPythonmacOsFramework.create.<locals>.<genexpr>)r �create�desired_mach_o_image_path�current_mach_o_image_path�_sources� isinstancer �mustr �COPY�symlinksr �base�extend�aliases� fix_mach_o�strr �max_size)r" �target�current�src�exes�exer r! r r$ s ��z CPythonmacOsFramework.createc # sL � t � �|�D ] \}}}}t|j�d d d d d }||||fV qd S )N� Resourcesz Python.app�Contents�MacOS�Python)r � _executablesr �prefix)r r �_�targetsr) �when�fixed_host_exer r r r; - s � �z"CPythonmacOsFramework._executablesc C � t �r ��NotImplementedErrorr! r r r r& 6 � z/CPythonmacOsFramework.current_mach_o_image_pathc C rA r rB r! r r r r% : rD z/CPythonmacOsFramework.desired_mach_o_image_path) �__name__� __module__� __qualname__� classmethodr r$ r; r r& r% � __classcell__r r r r r s r c s@ e Zd Zdd� Zdd� Ze� fdd��Ze� fdd��Z� Z S ) �CPython3macOsFrameworkc C � dS )Nz$@executable_path/../../../../Python3r r! r r r r& @ � z0CPython3macOsFramework.current_mach_o_image_pathc C rK )Nz@executable_path/../.Pythonr r! r r r r% C rL z0CPython3macOsFramework.desired_mach_o_image_pathc # s< � t � �|�E d H t|j�d }t|dd� tjd�V d S )N�Python3c S s | j d S )Nz.Python)�dest)r" r= r r r �<lambda>L s z0CPython3macOsFramework.sources.<locals>.<lambda>)rN r) )r �sourcesr r< r r �SYMLINK)r r r6 r r r rP F s �z CPython3macOsFramework.sourcesc s t � j}td|� d��S )Nz� # the bundled site.py always adds the global site package if we're on python framework build, escape this import sys before = sys._framework try: sys._framework = None z> finally: sys._framework = before )r � reload_coder )r" �resultr r r rR N s ��z"CPython3macOsFramework.reload_code) rE rF rG r& r% rH rP �propertyrR rI r r r r rJ ? s rJ c C s� zt �d| ||� t|�| ||� W dS tyH } z)t �d|� zdd||| g}t�|� W n ty< t�d� � w W Y d}~dS d}~ww )u� https://en.wikipedia.org/wiki/Mach-O. Mach-O, short for Mach object file format, is a file format for executables, object code, shared libraries, dynamically-loaded code, and core dumps. A replacement for the a.out format, Mach-O offers more extensibility and faster access to information in the symbol table. Each Mach-O file is made up of one Mach-O header, followed by a series of load commands, followed by one or more segments, each of which contains between 0 and 255 sections. Mach-O uses the REL relocation format to handle references to symbols. When looking up symbols Mach-O uses a two-level namespace that encodes each symbol into an 'object/symbol name' pair that is then linearly searched for by first the object and then the symbol name. The basic structure—a list of variable-length "load commands" that reference pages of data elsewhere in the file—was also used in the executable file format for Accent. The Accent file format was in turn, based on an idea from Spice Lisp. With the introduction of Mac OS X 10.6 platform the Mach-O file underwent a significant modification that causes binaries compiled on a computer running 10.6 or later to be (by default) executable only on computers running Mac OS X 10.6 or later. The difference stems from load commands that the dynamic linker, in previous Mac OS X versions, does not understand. Another significant change to the Mach-O format is the change in how the Link Edit tables (found in the __LINKEDIT section) function. In 10.6 these new Link Edit tables are compressed by removing unused and unneeded bits of information, however Mac OS X 10.5 and earlier cannot read this new Link Edit table format. z"change Mach-O for %s from %s to %szSCould not call _builtin_change_mac_o: %s. Trying to call install_name_tool instead.�install_name_toolz-changezUCould not call install_name_tool -- you must have Apple's development tools installedN) �LOGGER�debug�_builtin_change_mach_o� Exception�warning� subprocess� check_call�logging�fatal)r6 r3 �newr1 �e�cmdr r r r/ _ s ����r/ c sb d�d�d�d�d�d� d�d�G �� fd d �d ��dd d �� � ��������� � f dd�}|S )Nl �z�} l �m� l �z�} l �m� l �:� �>�<� c s\ e Zd ZdZd�fd� fdd� Zddd �Zd d � Zd d � Zddd�Zdd� Z �fdd�Z dS )z(_builtin_change_mach_o.<locals>.FileViewzZA proxy for file-like objects that exposes a given view of a file. Modified from macholib.r �return�Nonec s4 t |� �r |j| _n|| _|| _|| | _d| _d S )Nr )r( � _file_obj�_start�_end�_pos)r" �file_obj�start�size)�FileViewr r �__init__� s z1_builtin_change_mach_o.<locals>.FileView.__init__r0 c S s" d| j d�d| jd�d| j�d�S )Nz <fileview [�d�, z] rb )rh ri rg r! r r r �__repr__� s "z1_builtin_change_mach_o.<locals>.FileView.__repr__c S s | j S r )rj r! r r r �tell� s z-_builtin_change_mach_o.<locals>.FileView.tellc S sL | j | kr | jks$n |� d|d�d| j d�d| jd�d�}t|��d S )Nz to offset rp z is outside window [rq �])rh ri �OSError)r" �seek_to�op�msgr r r � _checkwindow� s &�z5_builtin_change_mach_o.<locals>.FileView._checkwindowc S s� |}|t jkr || j7 }n"|t jkr|| j| j 7 }n|t jkr&|| j7 }n d|��}t|��| �|d� | j � |� || j | _d S )Nz!Invalid whence argument to seek: �seek) �os�SEEK_SETrh �SEEK_CURrj �SEEK_ENDri ru ry rg rz )r" �offset�whencerv rx r r r rz � s z-_builtin_change_mach_o.<locals>.FileView.seekc S s^ | j | j }| �|d� | �|t|� d� | j�|tj� | j�|� | jt|�7 _d S )N�write) rh rj ry �lenrg rz r{ r| r� )r" �content�herer r r r� � s z._builtin_change_mach_o.<locals>.FileView.writec S sf |dksJ �| j | j }| �|d� t|| j| �}| j�|tj� | j� |�}| jt |�7 _|S )Nr �read) rh rj ry �minri rg rz r{ r| r� r� )r" rm r� � read_bytesr r r r� � s z-_builtin_change_mach_o.<locals>.FileView.readN)re rf )re r0 )r ) rE rF rG �__doc__ro rr rs ry rz r� r� r )rn �maxintr r rn � s rn r c S s6 t �|d| | �|d ��}t|�dkr|d S |S )z_Read a given number of 32-bits unsigned integers from the given file with the given endianness.�L� r r )�struct�unpackr� r� )�file�endian�num�resr r r � read_data� s z)_builtin_change_mach_o.<locals>.read_datac s� ����fdd��d� f����� � � � � ��f dd� � t ��t ��ks&J �t| d�� }� |� W d � dS 1 s;w Y dS )z� Replace a given name (what) in any LC_LOAD_DYLIB command found in the given binary with a new name (value), provided it's shorter. c s� �| |d�\}}}}}}|dkr�| |� t |�D ]Q} | �� } �| |d�\} } | � kra�| |�} | �| | tj� | �| | ��� }|d |�d�� }|�kra| �| | tj� | ��� � d � | �| | tj� qd S )N� �@ � � � ) �rangers rz r{ r| r� �decode�indexr� �encode)r� �bitsr� � _cpu_type� _cpu_sub_type� _file_type� n_commands�_size_of_commands�_flagsr= �wherera �cmd_size� name_offset�load)� LC_LOAD_DYLIBr� �value�whatr r �do_macho� s �z?_builtin_change_mach_o.<locals>.mach_o_change.<locals>.do_machor c s� �| ||�} � | � �}|�kr.� | � �}t |�D ]}� | � d�\}}}}}�| ||� qd S |�kr:� | d� � d S |�krF� | d�� d S |�krR� | d� � d S |�kr^� | d�� d S d S )N� � r� )r� ) r� r rm �magic� n_fat_archr= r� r� �_align) � BIG_ENDIAN� FAT_MAGICrn � LITTLE_ENDIAN�MH_CIGAM� MH_CIGAM_64�MH_MAGIC� MH_MAGIC_64�do_filer� r� r r r� � s" ��z>_builtin_change_mach_o.<locals>.mach_o_change.<locals>.do_filezr+bN)r� �open)�at_pathr� r� �f� r� r� rn r� r� r� r� r� r� r� r� )r� r� r� r� r � mach_o_change� s & "�z-_builtin_change_mach_o.<locals>.mach_o_change)r r )r� r� r r� r rX � s 8 9rX c s, e Zd Ze� fdd��Zedd� �Z� ZS )�CPython3macOsBrewc r r )r r r r r r r r r z CPython3macOsBrew.can_describec C s t � }d|_|S )NzTBrew disables copy creation: https://github.com/Homebrew/homebrew-core/issues/138159)r � copy_error)r r �metar r r � setup_meta s z CPython3macOsBrew.setup_meta)rE rF rG rH r r� rI r r r r r� s r� )r� rJ r )$r� � __future__r r] r{ r� r[ �abcr r �pathlibr �textwrapr �,virtualenv.create.via_global_ref.builtin.refr r r �;virtualenv.create.via_global_ref.builtin.via_global_self_dor �commonr r r r �cpython3r � getLoggerrE rV r rJ r/ rX r� �__all__r r r r �<module> s* % % builtin/cpython/__pycache__/cpython3.cpython-310.pyc 0000644 00000011720 15030253017 0016353 0 ustar 00 o }h� � @ s� d dl mZ d dlZd dlZd dlmZ d dlmZ d dl m Z d dl m Z d dl mZ d dlmZ d d lmZ d d lmZmZmZmZmZ G d d � d eeej�ZG dd� dee�ZG dd� dee�Z g d�Z dS )� )� annotationsN)�chain)� methodcaller)�Path)�dedent)�Python3Supports)� PathRefToDest)�is_store_python� )�CPython� CPythonPosix�CPythonWindows�is_mac_os_framework� is_macos_brewc @ s e Zd ZdZdS )�CPython3zCPython 3 or later.N)�__name__� __module__� __qualname__�__doc__� r r �d/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/cpython/cpython3.pyr s r c s8 e Zd Ze� fdd��Z� fdd�Zedd� �Z� ZS )� CPython3Posixc s$ t |�du ot|�du ot� �|�S )NF)r r �super� can_describe��cls� interpreter�� __class__r r r s � �zCPython3Posix.can_describec s& t � �� }| �| j�r|td�7 }|S )Na # for https://github.com/python/cpython/pull/9516, see https://github.com/pypa/virtualenv/issues/1704 import os if "__PYVENV_LAUNCHER__" in os.environ: del os.environ["__PYVENV_LAUNCHER__"] )r �env_patch_text�pyvenv_launch_patch_activer r )�self�textr r r r s �z CPython3Posix.env_patch_textc C s@ |j }|jdko d| kodkn p d| ko dkS S )N�darwin)� � � )r$ r% )r$ r& r$ )r$ r& )� version_info�platform)r r �verr r r r + s :z(CPython3Posix.pyvenv_launch_patch_active)r r r � classmethodr r r � __classcell__r r r r r s r c s� e Zd ZdZe� fdd��Zedd� �Ze� fdd��Zedd � �Zed d � �Z e� fd d ��Z edd� �Z edd� �Z � Z S )�CPython3WindowszCPython 3 on Windows.c s t |�rd S t� �|�S �N)r r � setup_metar r r r r. 4 s zCPython3Windows.setup_metac c sD � | � |�r | �|�}nt| �|�| �|�| �|��}|E d H d S r- )�has_shim� executablesr � dll_and_pyd� python_zip)r r �refsr r r �sources: s � �zCPython3Windows.sourcesc s t � �|�S r- )r r4 r r r r r0 F s zCPython3Windows.executablesc C s |j jdko | �|�d uS )Nr% )r' �minor�shimr r r r r/ J s zCPython3Windows.has_shimc C s* t |j�d d d d }|�� r|S d S )N�venv�scripts�ntz python.exe)r � system_stdlib�exists)r r r6 r r r r6 N s zCPython3Windows.shimc s | � |�r | �|�S t� �|�S r- )r/ r6 r � host_pythonr r r r r< U s zCPython3Windows.host_pythonc c sd � t |j�jg}t |j�d }|�� r|�|� |D ]}|�� D ]}|jdv r.t|| j �V q qd S )N�DLLs> �.dll�.pyd) r �system_executable�parent� system_prefix�is_dir�append�iterdir�suffixr �to_bin)r r �folders� dll_folder�folder�filer r r r1 ] s � ���zCPython3Windows.dll_and_pydc c s^ � d|j � d�}t�|j|�}tt|�}ttd�|�}t|d�}|dur-t|| j �V dS dS )a� "python{VERSION}.zip" contains compiled *.pyc std lib packages, where "VERSION" is `py_version_nodot` var from the `sysconfig` module. :see: https://docs.python.org/3/using/windows.html#the-embeddable-package :see: `discovery.py_info.PythonInfo` class (interpreter). :see: `python -m sysconfig` output. :note: The embeddable Python distribution for Windows includes "python{VERSION}.zip" and "python{VERSION}._pth" files. User can move/rename *zip* file and edit `sys.path` by editing *_pth* file. Here the `pattern` is used only for the default *zip* file name! z*pythonz.zipr; N) � version_nodot�fnmatch�filter�path�mapr �method�nextr rG )r r �pattern�matches� matched_paths�existing_pathsrO r r r r2 l s � �zCPython3Windows.python_zip)r r r r r* r. r4 r0 r/ r6 r< r1 r2 r+ r r r r r, 1 s$ r, )r r r, ) � __future__r �abcrM � itertoolsr �operatorr rQ �pathlibr �textwrapr �virtualenv.create.describer �,virtualenv.create.via_global_ref.builtin.refr �&virtualenv.create.via_global_ref.storer �commonr r r r r �ABCr r r, �__all__r r r r �<module> s R builtin/cpython/__pycache__/common.cpython-310.pyc 0000644 00000006377 15030253017 0016110 0 ustar 00 o }h� � @ s� d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl m Z m Z d dl m Z mZ d dlmZ G d d � d ee�ZG d d � d ee e�ZG d d� dee e�Zdd� Zdd� Ze�d�Zg d�ZdS )� )� annotationsN)�ABC)� OrderedDict)�Path)� PosixSupports�WindowsSupports)�RefMust�RefWhen)� ViaGlobalRefVirtualenvBuiltinc s, e Zd Ze� fdd��Zedd� �Z� ZS )�CPythonc s |j dko t� �|�S )Nr )�implementation�super� can_describe��cls� interpreter�� __class__� �b/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/cpython/common.pyr s zCPython.can_describec C s dS )N�pythonr )r r r r �exe_stem s zCPython.exe_stem)�__name__� __module__� __qualname__� classmethodr r � __classcell__r r r r r s r c @ s e Zd ZdZedd� �ZdS )� CPythonPosixz8Create a CPython virtual environment on POSIX platforms.c c sj � t |j�}|jj|jj}}tdd� dd|� �d|� d|� �|jfD ��}|t|�� �t j t j fV d S )Nc s s � | ]}|d fV qd S �Nr )�.0�ir r r � <genexpr> s � z,CPythonPosix._executables.<locals>.<genexpr>r �.) r �system_executable� version_info�major�minorr �name�list�keysr �NAr �ANY)r r �host_exer% r& �targetsr r r � _executables s � . zCPythonPosix._executablesN)r r r �__doc__r r. r r r r r s r c @ s$ e Zd Zedd� �Zedd� �ZdS )�CPythonWindowsc # sd � | � |�� � fdd�d� jhD �D ] }� |jgtjtjfV q� jd }||jgtjtjfV d S )Nc 3 s � | ]}� j | V qd S r )�parent)r �n��hostr r r! ) s � z.CPythonWindows._executables.<locals>.<genexpr>z python.exez pythonw.exe)� host_pythonr' r �COPYr r+ r1 )r r �path�python_wr r3 r r. # s � zCPythonWindows._executablesc C s t |j�S r )r r# r r r r r5 / s zCPythonWindows.host_pythonN)r r r r r. r5 r r r r r0 " s r0 c C s | j dkr | j�d�dkS dS )N�darwin�PYTHONFRAMEWORK�Python3F)�platform�sysconfig_vars�get�r r r r �is_mac_os_framework4 s r@ c C s | j dko t�| j�d uS )Nr9 )r< �_BREW� fullmatch� system_prefixr? r r r � is_macos_brew: s rD z�/(usr/local|opt/homebrew)/(opt/python@3\.\d{1,2}|Cellar/python@3\.\d{1,2}/3\.\d{1,2}\.\d{1,2})/Frameworks/Python\.framework/Versions/3\.\d{1,2})r r r0 r@ rD )� __future__r �re�abcr � collectionsr �pathlibr �virtualenv.create.describer r �,virtualenv.create.via_global_ref.builtin.refr r �;virtualenv.create.via_global_ref.builtin.via_global_self_dor r r r0 r@ rD �compilerA �__all__r r r r �<module> s" � builtin/cpython/mac_os.py 0000644 00000026625 15030253017 0011520 0 ustar 00 """The Apple Framework builds require their own customization.""" from __future__ import annotations import logging import os import struct import subprocess from abc import ABC, abstractmethod from pathlib import Path from textwrap import dedent from virtualenv.create.via_global_ref.builtin.ref import ( ExePathRefToDest, PathRefToDest, RefMust, ) from virtualenv.create.via_global_ref.builtin.via_global_self_do import BuiltinViaGlobalRefMeta from .common import CPython, CPythonPosix, is_mac_os_framework, is_macos_brew from .cpython3 import CPython3 LOGGER = logging.getLogger(__name__) class CPythonmacOsFramework(CPython, ABC): @classmethod def can_describe(cls, interpreter): return is_mac_os_framework(interpreter) and super().can_describe(interpreter) def create(self): super().create() # change the install_name of the copied python executables target = self.desired_mach_o_image_path() current = self.current_mach_o_image_path() for src in self._sources: if isinstance(src, ExePathRefToDest) and (src.must == RefMust.COPY or not self.symlinks): exes = [self.bin_dir / src.base] if not self.symlinks: exes.extend(self.bin_dir / a for a in src.aliases) for exe in exes: fix_mach_o(str(exe), current, target, self.interpreter.max_size) @classmethod def _executables(cls, interpreter): for _, targets, must, when in super()._executables(interpreter): # Make sure we use the embedded interpreter inside the framework, even if sys.executable points to the # stub executable in ${sys.prefix}/bin. # See http://groups.google.com/group/python-virtualenv/browse_thread/thread/17cab2f85da75951 fixed_host_exe = Path(interpreter.prefix) / "Resources" / "Python.app" / "Contents" / "MacOS" / "Python" yield fixed_host_exe, targets, must, when @abstractmethod def current_mach_o_image_path(self): raise NotImplementedError @abstractmethod def desired_mach_o_image_path(self): raise NotImplementedError class CPython3macOsFramework(CPythonmacOsFramework, CPython3, CPythonPosix): def current_mach_o_image_path(self): return "@executable_path/../../../../Python3" def desired_mach_o_image_path(self): return "@executable_path/../.Python" @classmethod def sources(cls, interpreter): yield from super().sources(interpreter) # add a symlink to the host python image exe = Path(interpreter.prefix) / "Python3" yield PathRefToDest(exe, dest=lambda self, _: self.dest / ".Python", must=RefMust.SYMLINK) @property def reload_code(self): result = super().reload_code return dedent( f""" # the bundled site.py always adds the global site package if we're on python framework build, escape this import sys before = sys._framework try: sys._framework = None {result} finally: sys._framework = before """, ) def fix_mach_o(exe, current, new, max_size): """ https://en.wikipedia.org/wiki/Mach-O. Mach-O, short for Mach object file format, is a file format for executables, object code, shared libraries, dynamically-loaded code, and core dumps. A replacement for the a.out format, Mach-O offers more extensibility and faster access to information in the symbol table. Each Mach-O file is made up of one Mach-O header, followed by a series of load commands, followed by one or more segments, each of which contains between 0 and 255 sections. Mach-O uses the REL relocation format to handle references to symbols. When looking up symbols Mach-O uses a two-level namespace that encodes each symbol into an 'object/symbol name' pair that is then linearly searched for by first the object and then the symbol name. The basic structure—a list of variable-length "load commands" that reference pages of data elsewhere in the file—was also used in the executable file format for Accent. The Accent file format was in turn, based on an idea from Spice Lisp. With the introduction of Mac OS X 10.6 platform the Mach-O file underwent a significant modification that causes binaries compiled on a computer running 10.6 or later to be (by default) executable only on computers running Mac OS X 10.6 or later. The difference stems from load commands that the dynamic linker, in previous Mac OS X versions, does not understand. Another significant change to the Mach-O format is the change in how the Link Edit tables (found in the __LINKEDIT section) function. In 10.6 these new Link Edit tables are compressed by removing unused and unneeded bits of information, however Mac OS X 10.5 and earlier cannot read this new Link Edit table format. """ try: LOGGER.debug("change Mach-O for %s from %s to %s", exe, current, new) _builtin_change_mach_o(max_size)(exe, current, new) except Exception as e: # noqa: BLE001 LOGGER.warning("Could not call _builtin_change_mac_o: %s. Trying to call install_name_tool instead.", e) try: cmd = ["install_name_tool", "-change", current, new, exe] subprocess.check_call(cmd) except Exception: logging.fatal("Could not call install_name_tool -- you must have Apple's development tools installed") raise def _builtin_change_mach_o(maxint): # noqa: C901 MH_MAGIC = 0xFEEDFACE # noqa: N806 MH_CIGAM = 0xCEFAEDFE # noqa: N806 MH_MAGIC_64 = 0xFEEDFACF # noqa: N806 MH_CIGAM_64 = 0xCFFAEDFE # noqa: N806 FAT_MAGIC = 0xCAFEBABE # noqa: N806 BIG_ENDIAN = ">" # noqa: N806 LITTLE_ENDIAN = "<" # noqa: N806 LC_LOAD_DYLIB = 0xC # noqa: N806 class FileView: """A proxy for file-like objects that exposes a given view of a file. Modified from macholib.""" def __init__(self, file_obj, start=0, size=maxint) -> None: if isinstance(file_obj, FileView): self._file_obj = file_obj._file_obj # noqa: SLF001 else: self._file_obj = file_obj self._start = start self._end = start + size self._pos = 0 def __repr__(self) -> str: return f"<fileview [{self._start:d}, {self._end:d}] {self._file_obj!r}>" def tell(self): return self._pos def _checkwindow(self, seek_to, op): if not (self._start <= seek_to <= self._end): msg = f"{op} to offset {seek_to:d} is outside window [{self._start:d}, {self._end:d}]" raise OSError(msg) def seek(self, offset, whence=0): seek_to = offset if whence == os.SEEK_SET: seek_to += self._start elif whence == os.SEEK_CUR: seek_to += self._start + self._pos elif whence == os.SEEK_END: seek_to += self._end else: msg = f"Invalid whence argument to seek: {whence!r}" raise OSError(msg) self._checkwindow(seek_to, "seek") self._file_obj.seek(seek_to) self._pos = seek_to - self._start def write(self, content): here = self._start + self._pos self._checkwindow(here, "write") self._checkwindow(here + len(content), "write") self._file_obj.seek(here, os.SEEK_SET) self._file_obj.write(content) self._pos += len(content) def read(self, size=maxint): assert size >= 0 # noqa: S101 here = self._start + self._pos self._checkwindow(here, "read") size = min(size, self._end - here) self._file_obj.seek(here, os.SEEK_SET) read_bytes = self._file_obj.read(size) self._pos += len(read_bytes) return read_bytes def read_data(file, endian, num=1): """Read a given number of 32-bits unsigned integers from the given file with the given endianness.""" res = struct.unpack(endian + "L" * num, file.read(num * 4)) if len(res) == 1: return res[0] return res def mach_o_change(at_path, what, value): # noqa: C901 """ Replace a given name (what) in any LC_LOAD_DYLIB command found in the given binary with a new name (value), provided it's shorter. """ # noqa: D205 def do_macho(file, bits, endian): # Read Mach-O header (the magic number is assumed read by the caller) _cpu_type, _cpu_sub_type, _file_type, n_commands, _size_of_commands, _flags = read_data(file, endian, 6) # 64-bits header has one more field. if bits == 64: # noqa: PLR2004 read_data(file, endian) # The header is followed by n commands for _ in range(n_commands): where = file.tell() # Read command header cmd, cmd_size = read_data(file, endian, 2) if cmd == LC_LOAD_DYLIB: # The first data field in LC_LOAD_DYLIB commands is the offset of the name, starting from the # beginning of the command. name_offset = read_data(file, endian) file.seek(where + name_offset, os.SEEK_SET) # Read the NUL terminated string load = file.read(cmd_size - name_offset).decode() load = load[: load.index("\0")] # If the string is what is being replaced, overwrite it. if load == what: file.seek(where + name_offset, os.SEEK_SET) file.write(value.encode() + b"\0") # Seek to the next command file.seek(where + cmd_size, os.SEEK_SET) def do_file(file, offset=0, size=maxint): file = FileView(file, offset, size) # Read magic number magic = read_data(file, BIG_ENDIAN) if magic == FAT_MAGIC: # Fat binaries contain nfat_arch Mach-O binaries n_fat_arch = read_data(file, BIG_ENDIAN) for _ in range(n_fat_arch): # Read arch header _cpu_type, _cpu_sub_type, offset, size, _align = read_data(file, BIG_ENDIAN, 5) do_file(file, offset, size) elif magic == MH_MAGIC: do_macho(file, 32, BIG_ENDIAN) elif magic == MH_CIGAM: do_macho(file, 32, LITTLE_ENDIAN) elif magic == MH_MAGIC_64: do_macho(file, 64, BIG_ENDIAN) elif magic == MH_CIGAM_64: do_macho(file, 64, LITTLE_ENDIAN) assert len(what) >= len(value) # noqa: S101 with open(at_path, "r+b") as f: do_file(f) return mach_o_change class CPython3macOsBrew(CPython3, CPythonPosix): @classmethod def can_describe(cls, interpreter): return is_macos_brew(interpreter) and super().can_describe(interpreter) @classmethod def setup_meta(cls, interpreter): # noqa: ARG003 meta = BuiltinViaGlobalRefMeta() meta.copy_error = "Brew disables copy creation: https://github.com/Homebrew/homebrew-core/issues/138159" return meta __all__ = [ "CPython3macOsBrew", "CPython3macOsFramework", "CPythonmacOsFramework", ] builtin/cpython/common.py 0000644 00000004721 15030253017 0011540 0 ustar 00 from __future__ import annotations import re from abc import ABC from collections import OrderedDict from pathlib import Path from virtualenv.create.describe import PosixSupports, WindowsSupports from virtualenv.create.via_global_ref.builtin.ref import RefMust, RefWhen from virtualenv.create.via_global_ref.builtin.via_global_self_do import ViaGlobalRefVirtualenvBuiltin class CPython(ViaGlobalRefVirtualenvBuiltin, ABC): @classmethod def can_describe(cls, interpreter): return interpreter.implementation == "CPython" and super().can_describe(interpreter) @classmethod def exe_stem(cls): return "python" class CPythonPosix(CPython, PosixSupports, ABC): """Create a CPython virtual environment on POSIX platforms.""" @classmethod def _executables(cls, interpreter): host_exe = Path(interpreter.system_executable) major, minor = interpreter.version_info.major, interpreter.version_info.minor targets = OrderedDict((i, None) for i in ["python", f"python{major}", f"python{major}.{minor}", host_exe.name]) yield host_exe, list(targets.keys()), RefMust.NA, RefWhen.ANY class CPythonWindows(CPython, WindowsSupports, ABC): @classmethod def _executables(cls, interpreter): # symlink of the python executables does not work reliably, copy always instead # - https://bugs.python.org/issue42013 # - venv host = cls.host_python(interpreter) for path in (host.parent / n for n in {"python.exe", host.name}): yield host, [path.name], RefMust.COPY, RefWhen.ANY # for more info on pythonw.exe see https://stackoverflow.com/a/30313091 python_w = host.parent / "pythonw.exe" yield python_w, [python_w.name], RefMust.COPY, RefWhen.ANY @classmethod def host_python(cls, interpreter): return Path(interpreter.system_executable) def is_mac_os_framework(interpreter): if interpreter.platform == "darwin": return interpreter.sysconfig_vars.get("PYTHONFRAMEWORK") == "Python3" return False def is_macos_brew(interpreter): return interpreter.platform == "darwin" and _BREW.fullmatch(interpreter.system_prefix) is not None _BREW = re.compile( r"/(usr/local|opt/homebrew)/(opt/python@3\.\d{1,2}|Cellar/python@3\.\d{1,2}/3\.\d{1,2}\.\d{1,2})/Frameworks/" r"Python\.framework/Versions/3\.\d{1,2}", ) __all__ = [ "CPython", "CPythonPosix", "CPythonWindows", "is_mac_os_framework", "is_macos_brew", ] builtin/cpython/__init__.py 0000644 00000000000 15030253017 0011771 0 ustar 00 builtin/via_global_self_do.py 0000644 00000010516 15030253017 0012355 0 ustar 00 from __future__ import annotations from abc import ABC from virtualenv.create.via_global_ref.api import ViaGlobalRefApi, ViaGlobalRefMeta from virtualenv.create.via_global_ref.builtin.ref import ( ExePathRefToDest, RefMust, RefWhen, ) from virtualenv.util.path import ensure_dir from .builtin_way import VirtualenvBuiltin class BuiltinViaGlobalRefMeta(ViaGlobalRefMeta): def __init__(self) -> None: super().__init__() self.sources = [] class ViaGlobalRefVirtualenvBuiltin(ViaGlobalRefApi, VirtualenvBuiltin, ABC): def __init__(self, options, interpreter) -> None: super().__init__(options, interpreter) self._sources = getattr(options.meta, "sources", None) # if we're created as a describer this might be missing @classmethod def can_create(cls, interpreter): """By default, all built-in methods assume that if we can describe it we can create it.""" # first we must be able to describe it if not cls.can_describe(interpreter): return None meta = cls.setup_meta(interpreter) if meta is not None and meta: cls._sources_can_be_applied(interpreter, meta) return meta @classmethod def _sources_can_be_applied(cls, interpreter, meta): for src in cls.sources(interpreter): if src.exists: if meta.can_copy and not src.can_copy: meta.copy_error = f"cannot copy {src}" if meta.can_symlink and not src.can_symlink: meta.symlink_error = f"cannot symlink {src}" else: msg = f"missing required file {src}" if src.when == RefMust.NA: meta.error = msg elif src.when == RefMust.COPY: meta.copy_error = msg elif src.when == RefMust.SYMLINK: meta.symlink_error = msg if not meta.can_copy and not meta.can_symlink: meta.error = f"neither copy or symlink supported, copy: {meta.copy_error} symlink: {meta.symlink_error}" if meta.error: break meta.sources.append(src) @classmethod def setup_meta(cls, interpreter): # noqa: ARG003 return BuiltinViaGlobalRefMeta() @classmethod def sources(cls, interpreter): for host_exe, targets, must, when in cls._executables(interpreter): yield ExePathRefToDest(host_exe, dest=cls.to_bin, targets=targets, must=must, when=when) def to_bin(self, src): return self.bin_dir / src.name @classmethod def _executables(cls, interpreter): raise NotImplementedError def create(self): dirs = self.ensure_directories() for directory in list(dirs): if any(i for i in dirs if i is not directory and directory.parts == i.parts[: len(directory.parts)]): dirs.remove(directory) for directory in sorted(dirs): ensure_dir(directory) self.set_pyenv_cfg() self.pyenv_cfg.write() true_system_site = self.enable_system_site_package try: self.enable_system_site_package = False for src in self._sources: if ( src.when == RefWhen.ANY or (src.when == RefWhen.SYMLINK and self.symlinks is True) or (src.when == RefWhen.COPY and self.symlinks is False) ): src.run(self, self.symlinks) finally: if true_system_site != self.enable_system_site_package: self.enable_system_site_package = true_system_site super().create() def ensure_directories(self): return {self.dest, self.bin_dir, self.script_dir, self.stdlib} | set(self.libs) def set_pyenv_cfg(self): """ We directly inject the base prefix and base exec prefix to avoid site.py needing to discover these from home (which usually is done within the interpreter itself). """ # noqa: D205 super().set_pyenv_cfg() self.pyenv_cfg["base-prefix"] = self.interpreter.system_prefix self.pyenv_cfg["base-exec-prefix"] = self.interpreter.system_exec_prefix self.pyenv_cfg["base-executable"] = self.interpreter.system_executable __all__ = [ "BuiltinViaGlobalRefMeta", "ViaGlobalRefVirtualenvBuiltin", ] builtin/__pycache__/builtin_way.cpython-310.pyc 0000644 00000001626 15030253017 0015452 0 ustar 00 o }h � @ sN d dl mZ d dlmZ d dlmZ d dlmZ G dd� deee�ZdgZ dS )� )� annotations)�ABC)�Creator)�Describec @ s e Zd ZdZddd�ZdS )�VirtualenvBuiltinzfA creator that does operations itself without delegation, if we can create it we can also describe it.�return�Nonec C s" t �| ||� t�| | j|� d S )N)r �__init__r �dest)�self�options� interpreter� r �_/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/builtin_way.pyr s zVirtualenvBuiltin.__init__N)r r )�__name__� __module__� __qualname__�__doc__r r r r r r s r N) � __future__r �abcr �virtualenv.create.creatorr �virtualenv.create.describer r �__all__r r r r �<module> s � builtin/__pycache__/__init__.cpython-310.pyc 0000644 00000000271 15030253017 0014656 0 ustar 00 o }h � @ s d S )N� r r r �\/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/__init__.py�<module> s builtin/__pycache__/via_global_self_do.cpython-310.pyc 0000644 00000011217 15030253017 0016713 0 ustar 00 o }hN � @ s� d dl mZ d dlmZ d dlmZmZ d dlmZm Z m Z d dl m Z ddl mZ G dd � d e�ZG d d � d eee�Zd d gZd S ) � )� annotations)�ABC)�ViaGlobalRefApi�ViaGlobalRefMeta)�ExePathRefToDest�RefMust�RefWhen)� ensure_dir� )�VirtualenvBuiltinc s e Zd Zd� fdd� Z� ZS )�BuiltinViaGlobalRefMeta�return�Nonec s t � �� g | _d S �N)�super�__init__�sources��self�� __class__� �f/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/via_global_self_do.pyr s z BuiltinViaGlobalRefMeta.__init__�r r )�__name__� __module__� __qualname__r � __classcell__r r r r r s r c s� e Zd Zd� fdd� Zedd� �Zedd� �Zed d � �Zed d � �Zd d� Z edd� �Z � fdd�Z dd� Z � fdd�Z � ZS )� ViaGlobalRefVirtualenvBuiltinr r c s" t � �||� t|jdd �| _d S )Nr )r r �getattr�meta�_sources)r �options� interpreterr r r r s z&ViaGlobalRefVirtualenvBuiltin.__init__c C s4 | � |�sdS | �|�}|dur|r| �||� |S )zTBy default, all built-in methods assume that if we can describe it we can create it.N)� can_describe� setup_meta�_sources_can_be_applied)�clsr# r r r r � can_create s z(ViaGlobalRefVirtualenvBuiltin.can_createc C s� | � |�D ]]}|jr#|jr|jsd|� �|_|jr"|js"d|� �|_n"d|� �}|jtjkr2||_ n|jtj kr<||_n |jtj krE||_|jsV|jsVd|j� d|j� �|_ |j r\ d S |j � |� qd S )Nz cannot copy zcannot symlink zmissing required file z)neither copy or symlink supported, copy: z symlink: ) r �exists�can_copy� copy_error� can_symlink� symlink_error�whenr �NA�error�COPY�SYMLINK�append)r' r# r �src�msgr r r r& & s( � �z5ViaGlobalRefVirtualenvBuiltin._sources_can_be_appliedc C s t � S r )r �r' r# r r r r% < s z(ViaGlobalRefVirtualenvBuiltin.setup_metac c s4 � | � |�D ]\}}}}t|| j|||d�V qd S )N)�dest�targets�mustr. )� _executablesr �to_bin)r' r# �host_exer8 r9 r. r r r r @ s ��z%ViaGlobalRefVirtualenvBuiltin.sourcesc C s | j |j S r )�bin_dir�name)r r4 r r r r; E s z$ViaGlobalRefVirtualenvBuiltin.to_binc C s t �r )�NotImplementedErrorr6 r r r r: H s z*ViaGlobalRefVirtualenvBuiltin._executablesc s� | � � }t|�D ]� t� fdd�|D ��r|�� � qt|�D ]� t� � q | �� | j�� | j }z6d| _ | j D ]%}|j t j ksW|j t jkrL| jdu sW|j t jkr^| jdu r^|�| | j� q9W || j krh|| _ n || j krq|| _ w t� �� d S )Nc 3 s6 � | ]}|� ur� j |j d t� j �� kr|V qd S r )�parts�len)�.0�i�� directoryr r � <genexpr>O s �4 z7ViaGlobalRefVirtualenvBuiltin.create.<locals>.<genexpr>FT)�ensure_directories�list�any�remove�sortedr � set_pyenv_cfg� pyenv_cfg�write�enable_system_site_packager! r. r �ANYr2 �symlinksr1 �runr �create)r �dirs�true_system_siter4 r rD r rS L s2 � �� � �z$ViaGlobalRefVirtualenvBuiltin.createc C s | j | j| j| jht| j�B S r )r7 r= � script_dir�stdlib�set�libsr r r r rG e s z0ViaGlobalRefVirtualenvBuiltin.ensure_directoriesc s8 t � �� | jj| jd< | jj| jd< | jj| jd< dS )z� We directly inject the base prefix and base exec prefix to avoid site.py needing to discover these from home (which usually is done within the interpreter itself). z base-prefixzbase-exec-prefixzbase-executableN)r rL r# � system_prefixrM �system_exec_prefix�system_executabler r r r rL h s z+ViaGlobalRefVirtualenvBuiltin.set_pyenv_cfgr )r r r r � classmethodr( r& r% r r; r: rS rG rL r r r r r r s r N)� __future__r �abcr �$virtualenv.create.via_global_ref.apir r �,virtualenv.create.via_global_ref.builtin.refr r r �virtualenv.util.pathr � builtin_wayr r r �__all__r r r r �<module> s ^� builtin/__pycache__/ref.cpython-310.pyc 0000644 00000014204 15030253017 0013674 0 ustar 00 o }h9 � @ s� d Z ddlmZ ddlZddlmZmZ ddlmZ ddl m Z m Z m Z ddl mZmZ ddlmZmZmZ G d d � d �ZG d d � d �ZG d d� de�ZG dd� dee�ZG dd� de�ZG dd� dee�Zg d�ZdS )aG Virtual environments in the traditional sense are built as reference to the host python. This file allows declarative references to elements on the file system, allowing our system to automatically detect what modes it can support given the constraints: e.g. can the file system symlink, can the files be read, executed, etc. � )� annotationsN)�ABC�abstractmethod)� OrderedDict)�S_IXGRP�S_IXOTH�S_IXUSR)�fs_is_case_sensitive�fs_supports_symlink)�copy�make_exe�symlinkc @ � e Zd ZdZdZdZdS )�RefMust�NAr r N)�__name__� __module__� __qualname__r �COPY�SYMLINK� r r �W/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/ref.pyr � r c @ r )�RefWhen�ANYr r N)r r r r r r r r r r r r r c @ sr e Zd ZdZe� Ze� Zej e j fddd�Z ddd�Z ed d � �Zed d � �Zed d� �Zedd� �Zdd� ZdS )�PathRefzABase class that checks if a file reference can be symlink/copied.�return�Nonec C st || _ || _|| _z|�� | _W n ty d| _Y nw | jr"d nd| _| jr*d nd| _| jr5d | _d S d| _d S �NF)�must�when�src�exists�OSError� _can_read� _can_copy� _can_symlink��selfr! r r r r r �__init__$ s �zPathRef.__init__�strc C s | j j� d| j� d�S )N�(src=�))� __class__r r! �r( r r r �__repr__0 s zPathRef.__repr__c C s� | j d u rE| j�� r:z!| j�d�� d| _ W d � n 1 s w Y W | j S W | j S ty9 d| _ Y | j S w t�t| j�tj�| _ | j S )N�rbTF) r$ r! �is_file�openr# �os�accessr* �R_OKr. r r r �can_read3 s �� ��zPathRef.can_readc C s2 | j d u r| jtjkr| j| _ | j S | j| _ | j S �N)r% r r r � can_symlinkr6 r. r r r �can_copy@ s �zPathRef.can_copyc C s8 | j d u r| jtjkr| j| _ | j S | jo| j| _ | j S r7 )r& r r r r9 �FS_SUPPORTS_SYMLINKr6 r. r r r r8 I s �zPathRef.can_symlinkc C s t �r7 )�NotImplementedError)r( �creator�symlinksr r r �runR s z PathRef.runc C s, | j tjkrtS | j tjkrtS |rtS tS r7 )r r r r r r )r( r= r r r �methodV s zPathRef.methodN�r r �r r* )r r r �__doc__r r: r �FS_CASE_SENSITIVEr r r r r) r/ �propertyr6 r9 r8 r r> r? r r r r r s r c sD e Zd ZdZejejfd � fdd� Ze dd� �Z e dd � �Z � Z S ) � ExePathRefzJBase class that checks if a executable can be references via symlink/copy.r r c s t � �|||� d | _d S r7 )�superr) �_can_runr' �r- r r r) a � zExePathRef.__init__c C s | j r| jS dS r )r: �can_runr. r r r r8 e s zExePathRef.can_symlinkc C sF | j d u r | j�� j}tttfD ] }||@ rd| _ | j S d| _ | j S )NTF)rG r! �stat�st_moder r r )r( �mode�keyr r r rJ k s �zExePathRef.can_runr@ ) r r r rB r r r r r) rD r8 rJ � __classcell__r r rH r rE ^ s rE c s4 e Zd ZdZejejfd� fdd� Zdd� Z � Z S ) � PathRefToDestz Link a path on the file system.r r c s t � �|||� || _d S r7 )rF r) �dest)r( r! rQ r r rH r r r) { rI zPathRefToDest.__init__c C s` | � || j�}| �|�}t|t�r|n|f}|j�� s#|jjddd� |D ]}|| j|� q%d S )NT)�parents�exist_ok)rQ r! r? � isinstance�list�parentr" �mkdir)r( r< r= rQ r? � dest_iterable�dstr r r r> s �zPathRefToDest.runr@ ) r r r rB r r r r r) r> rO r r rH r rP x s rP c @ s6 e Zd ZdZejejfd dd�Zdd� Z d d d �Z d S )�ExePathRefToDestz#Link a exe path on the file system.r r c C sd t �| |||� t�| ||||� | js!ttdd� |D ���� �}|d | _|dd � | _|| _ d S )Nc s s � | ] }|� � d fV qd S r7 )�lower)�.0�ir r r � <genexpr>� s � z,ExePathRefToDest.__init__.<locals>.<genexpr>r � ) rE r) rP rC rU r �keys�base�aliasesrQ )r( r! �targetsrQ r r r r r r) � s zExePathRefToDest.__init__c C s� | � || j�j}|| j }| �|�}|| j|� |s t|� | jD ]#}|| }|�� r/|�� |r8|� | j� nt | j|� |sDt|� q!d S r7 ) rQ r! rV ra r? r rb r" �unlink� symlink_tor )r( r< r= �bin_dirrQ r? �extra� link_filer r r r> � s" ��zExePathRefToDest.runr* c C s | j j� d| j� d| j� d�S )Nr+ z, alias=r, )r- r r! rb r. r r r r/ � s zExePathRefToDest.__repr__Nr@ rA ) r r r rB r r r r r) r> r/ r r r r rZ � s rZ )rE rZ r rP r r )rB � __future__r r3 �abcr r � collectionsr rK r r r �virtualenv.infor r �virtualenv.util.pathr r r r r r rE rP rZ �__all__r r r r �<module> s @ " builtin/builtin_way.py 0000644 00000001010 15030253017 0011076 0 ustar 00 from __future__ import annotations from abc import ABC from virtualenv.create.creator import Creator from virtualenv.create.describe import Describe class VirtualenvBuiltin(Creator, Describe, ABC): """A creator that does operations itself without delegation, if we can create it we can also describe it.""" def __init__(self, options, interpreter) -> None: Creator.__init__(self, options, interpreter) Describe.__init__(self, self.dest, interpreter) __all__ = [ "VirtualenvBuiltin", ] builtin/graalpy/__pycache__/__init__.cpython-310.pyc 0000644 00000007511 15030253017 0016321 0 ustar 00 o }h� � @ s� d dl mZ d dlmZ d dlmZ d dlmZmZ d dl m Z m Z m Z d dl mZ G dd� dee�ZG d d � d ee�ZG d d � d ee�Zd d gZd S )� )� annotations)�ABC)�Path)� PosixSupports�WindowsSupports)� PathRefToDest�RefMust�RefWhen)� ViaGlobalRefVirtualenvBuiltinc sl e Zd Ze� fdd��Zedd� �Zedd� �Zedd� �Ze� fd d ��Zed d � �Z � fd d�Z � Z S )�GraalPyc s |j dko t� �|�S )N�GraalVM)�implementation�super� can_describe��cls� interpreter�� __class__� �d/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/graalpy/__init__.pyr s zGraalPy.can_describec C s dS )N�graalpyr �r r r r �exe_stem � zGraalPy.exe_stemc C s. | � � dd|jj� �d|jj� d|jj� �hS )N�python�.)r � version_info�major�minorr r r r � exe_names s �zGraalPy.exe_namesc # s> � t |j�}t� fdd�� �|�D ��}||tjtjfV d S )Nc 3 s � | ] }|� � j � �V qd S �N)�suffix)�.0�namer r r � <genexpr> s � z'GraalPy._executables.<locals>.<genexpr>)r �system_executable�sortedr r �NAr �ANY)r r �host�targetsr r r � _executables s � zGraalPy._executablesc # s� � t � �|�E d H t|j��� j}|jdv r|j}| �|d |j�}|� � r0t |dd� d�V dD ]}|| }|� � rEt |dd� d�V q2d S )N> �bin�Scripts�libc S s | j jd |j S )Nr/ ��bin_dir�parentr$ ��self�sr r r �<lambda>, s z!GraalPy.sources.<locals>.<lambda>)�dest)�jvm�jvmlibs�modulesc S s | j j|j S r! r0 r3 r r r r6 1 s ) r �sourcesr r& �resolver2 r$ � _native_lib�platform�existsr )r r � python_dir� native_lib� jvm_dir_name�jvm_dirr r r r; # s � ��zGraalPy.sourcesc C s t �r! )�NotImplementedError)r r@ r r r � _shared_libs3 r zGraalPy._shared_libsc s^ t � �� | jj}|jdkr)|jdkr+t| jd �}|jdkr-t |j �| jd< d S d S d S d S )N� � �homer- ) r � set_pyenv_cfgr r r r r � pyenv_cfgr$ �strr2 )r4 �versionrH r r r rI 7 s �zGraalPy.set_pyenv_cfg) �__name__� __module__� __qualname__� classmethodr r r r, r; rE rI � __classcell__r r r r r s r c @ s e Zd Zedd� �ZdS )� GraalPyPosixc C s |dkr|d S |d S )N�darwinzlibpythonvm.dylibzlibpythonvm.sor )r �lib_dirr> r r r r= B s zGraalPyPosix._native_libN)rM rN rO rP r= r r r r rR A s rR c s( e Zd Zedd� �Z� fdd�Z� ZS )�GraalPyWindowsc C s |d S )Nz pythonvm.dllr )r rT � _platformr r r r= J s zGraalPyWindows._native_libc s t � �� | jj| jd< d S )N�venvlauncher_command)r rI r r& rJ )r4 r r r rI N s z GraalPyWindows.set_pyenv_cfg)rM rN rO rP r= rI rQ r r r r rU I s rU N)� __future__r �abcr �pathlibr �virtualenv.create.describer r �,virtualenv.create.via_global_ref.builtin.refr r r �;virtualenv.create.via_global_ref.builtin.via_global_self_dor r rR rU �__all__r r r r �<module> s 6 � builtin/graalpy/__init__.py 0000644 00000005652 15030253017 0011766 0 ustar 00 from __future__ import annotations from abc import ABC from pathlib import Path from virtualenv.create.describe import PosixSupports, WindowsSupports from virtualenv.create.via_global_ref.builtin.ref import PathRefToDest, RefMust, RefWhen from virtualenv.create.via_global_ref.builtin.via_global_self_do import ViaGlobalRefVirtualenvBuiltin class GraalPy(ViaGlobalRefVirtualenvBuiltin, ABC): @classmethod def can_describe(cls, interpreter): return interpreter.implementation == "GraalVM" and super().can_describe(interpreter) @classmethod def exe_stem(cls): return "graalpy" @classmethod def exe_names(cls, interpreter): return { cls.exe_stem(), "python", f"python{interpreter.version_info.major}", f"python{interpreter.version_info.major}.{interpreter.version_info.minor}", } @classmethod def _executables(cls, interpreter): host = Path(interpreter.system_executable) targets = sorted(f"{name}{cls.suffix}" for name in cls.exe_names(interpreter)) yield host, targets, RefMust.NA, RefWhen.ANY @classmethod def sources(cls, interpreter): yield from super().sources(interpreter) python_dir = Path(interpreter.system_executable).resolve().parent if python_dir.name in {"bin", "Scripts"}: python_dir = python_dir.parent native_lib = cls._native_lib(python_dir / "lib", interpreter.platform) if native_lib.exists(): yield PathRefToDest(native_lib, dest=lambda self, s: self.bin_dir.parent / "lib" / s.name) for jvm_dir_name in ("jvm", "jvmlibs", "modules"): jvm_dir = python_dir / jvm_dir_name if jvm_dir.exists(): yield PathRefToDest(jvm_dir, dest=lambda self, s: self.bin_dir.parent / s.name) @classmethod def _shared_libs(cls, python_dir): raise NotImplementedError def set_pyenv_cfg(self): super().set_pyenv_cfg() # GraalPy 24.0 and older had home without the bin version = self.interpreter.version_info if version.major == 3 and version.minor <= 10: # noqa: PLR2004 home = Path(self.pyenv_cfg["home"]) if home.name == "bin": self.pyenv_cfg["home"] = str(home.parent) class GraalPyPosix(GraalPy, PosixSupports): @classmethod def _native_lib(cls, lib_dir, platform): if platform == "darwin": return lib_dir / "libpythonvm.dylib" return lib_dir / "libpythonvm.so" class GraalPyWindows(GraalPy, WindowsSupports): @classmethod def _native_lib(cls, lib_dir, _platform): return lib_dir / "pythonvm.dll" def set_pyenv_cfg(self): # GraalPy needs an additional entry in pyvenv.cfg on Windows super().set_pyenv_cfg() self.pyenv_cfg["venvlauncher_command"] = self.interpreter.system_executable __all__ = [ "GraalPyPosix", "GraalPyWindows", ] builtin/pypy/__pycache__/__init__.cpython-310.pyc 0000644 00000000276 15030253017 0015664 0 ustar 00 o }h � @ s d S )N� r r r �a/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/pypy/__init__.py�<module> s builtin/pypy/__pycache__/pypy3.cpython-310.pyc 0000644 00000004750 15030253017 0015212 0 ustar 00 o }h� � @ s� d dl mZ d dlZd dlmZ d dlmZmZmZ d dl m Z ddl m Z G dd � d e eej �ZG d d � d ee�ZG d d � d ee�Zg d�ZdS )� )� annotationsN)�Path)� PosixSupports�Python3Supports�WindowsSupports)� PathRefToDest� )�PyPyc s, e Zd Zedd� �Ze� fdd��Z� ZS )�PyPy3c C s dS )N�pypy3� )�clsr r �^/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/pypy/pypy3.py�exe_stem s zPyPy3.exe_stemc s t � �|�dhB S )N�pypy)�super� exe_names)r � interpreter�� __class__r r r s zPyPy3.exe_names)�__name__� __module__� __qualname__� classmethodr r � __classcell__r r r r r s r c s8 e Zd ZdZedd� �Zdd� Ze� fdd��Z� ZS )� PyPy3PosixzPyPy 3 on POSIX.c C s |� d�S )Nz libpypy3*.*��glob)r � python_dirr r r � _shared_libs s zPyPy3Posix._shared_libsc C s | j d |j S )N�lib)�dest�name)�self�srcr r r �to_lib s zPyPy3Posix.to_libc # s~ � t � �|�E d H |jdkrd S t|j�d }t|j�}|�� r9|�� r;|�� D ]}||kr0q)t|| j d�V q)d S d S d S )Nz/usrr )r! ) r �sources� system_prefixr � system_stdlib�exists�is_dir�iterdirr r% )r r �host_lib�stdlib�pathr r r r& ! s � �zPyPy3Posix.sources) r r r �__doc__r r r% r& r r r r r r s r c @ s( e Zd ZdZedd� �Zedd� �ZdS )� Pypy3WindowszPyPy 3 on Windows.c C s | j jjdk S )N� )r � version_info�minor)r# r r r �less_v37< s zPypy3Windows.less_v37c c s$ � dD ] }|� |�}|E d H qd S )N)z libpypy*.dllz libffi*.dllr )r r �pattern�srcsr r r r @ s � �zPypy3Windows._shared_libsN)r r r r/ �propertyr4 r r r r r r r0 9 s r0 )r r r0 )� __future__r �abc�pathlibr �virtualenv.create.describer r r �,virtualenv.create.via_global_ref.builtin.refr �commonr �ABCr r r0 �__all__r r r r �<module> s # builtin/pypy/__pycache__/common.cpython-310.pyc 0000644 00000004640 15030253017 0015414 0 ustar 00 o }h� � @ s^ d dl mZ d dlZd dlmZ d dlmZmZmZ d dl m Z G dd� de ej �Z dgZ dS )� )� annotationsN)�Path)� PathRefToDest�RefMust�RefWhen)� ViaGlobalRefVirtualenvBuiltinc sl e Zd Ze� fdd��Zedd� �Ze� fdd��Zedd� �Zed d � �Zed d � �Z ed d� �Z � Z S )�PyPyc s |j dko t� �|�S )Nr )�implementation�super� can_describe��cls� interpreter�� __class__� �_/usr/local/lib/python3.10/dist-packages/virtualenv/create/via_global_ref/builtin/pypy/common.pyr s zPyPy.can_describec c s: � t |j�}tdd� | �|�D ��}||tjtjfV d S )Nc s s � | ] }|� t j� �V qd S �N)r �suffix)�.0�namer r r � <genexpr> s � z$PyPy._executables.<locals>.<genexpr>)r �system_executable�sorted� exe_namesr �NAr �ANY)r r �host�targetsr r r � _executables s � zPyPy._executablesc # s � t � �|�E d H d S r )r �sourcesr r r r � executables s �zPyPy.executablesc C s. | � � dd|jj� �d|jj� d|jj� �hS )N�python�.)�exe_stem� version_info�major�minorr r r r r s �zPyPy.exe_namesc c s8 � | � |�E d H | �|�D ] }t|dd� d�V qd S )Nc S s | j |j S r )�bin_dirr )�self�sr r r �<lambda>& s z PyPy.sources.<locals>.<lambda>)�dest)r! �_add_shared_libsr )r r r r r r r " s ��z PyPy.sourcesc c s& � t |j��� j}| �|�E d H d S r )r r �resolve�parent� _shared_libs)r r � python_dirr r r r- ( s �zPyPy._add_shared_libsc C s t �r )�NotImplementedError)r r1 r r r r0 . s zPyPy._shared_libs) �__name__� __module__� __qualname__� classmethodr r r! r r r- r0 � __classcell__r r r r r s r )� __future__r �abc�pathlibr �,virtualenv.create.via_global_ref.builtin.refr r r �;virtualenv.create.via_global_ref.builtin.via_global_self_dor �ABCr �__all__r r r r �<module> s *� builtin/pypy/pypy3.py 0000644 00000004676 15030253017 0010662 0 ustar 00 from __future__ import annotations import abc from pathlib import Path from virtualenv.create.describe import PosixSupports, Python3Supports, WindowsSupports from virtualenv.create.via_global_ref.builtin.ref import PathRefToDest from .common import PyPy class PyPy3(PyPy, Python3Supports, abc.ABC): @classmethod def exe_stem(cls): return "pypy3" @classmethod def exe_names(cls, interpreter): return super().exe_names(interpreter) | {"pypy"} class PyPy3Posix(PyPy3, PosixSupports): """PyPy 3 on POSIX.""" @classmethod def _shared_libs(cls, python_dir): # glob for libpypy3-c.so, libpypy3-c.dylib, libpypy3.9-c.so ... return python_dir.glob("libpypy3*.*") def to_lib(self, src): return self.dest / "lib" / src.name @classmethod def sources(cls, interpreter): yield from super().sources(interpreter) # PyPy >= 3.8 supports a standard prefix installation, where older # versions always used a portable/development style installation. # If this is a standard prefix installation, skip the below: if interpreter.system_prefix == "/usr": return # Also copy/symlink anything under prefix/lib, which, for "portable" # PyPy builds, includes the tk,tcl runtime and a number of shared # objects. In distro-specific builds or on conda this should be empty # (on PyPy3.8+ it will, like on CPython, hold the stdlib). host_lib = Path(interpreter.system_prefix) / "lib" stdlib = Path(interpreter.system_stdlib) if host_lib.exists() and host_lib.is_dir(): for path in host_lib.iterdir(): if stdlib == path: # For PyPy3.8+ the stdlib lives in lib/pypy3.8 # We need to avoid creating a symlink to it since that # will defeat the purpose of a virtualenv continue yield PathRefToDest(path, dest=cls.to_lib) class Pypy3Windows(PyPy3, WindowsSupports): """PyPy 3 on Windows.""" @property def less_v37(self): return self.interpreter.version_info.minor < 7 # noqa: PLR2004 @classmethod def _shared_libs(cls, python_dir): # glob for libpypy*.dll and libffi*.dll for pattern in ["libpypy*.dll", "libffi*.dll"]: srcs = python_dir.glob(pattern) yield from srcs __all__ = [ "PyPy3", "PyPy3Posix", "Pypy3Windows", ] builtin/pypy/common.py 0000644 00000003264 15030253017 0011056 0 ustar 00 from __future__ import annotations import abc from pathlib import Path from virtualenv.create.via_global_ref.builtin.ref import PathRefToDest, RefMust, RefWhen from virtualenv.create.via_global_ref.builtin.via_global_self_do import ViaGlobalRefVirtualenvBuiltin class PyPy(ViaGlobalRefVirtualenvBuiltin, abc.ABC): @classmethod def can_describe(cls, interpreter): return interpreter.implementation == "PyPy" and super().can_describe(interpreter) @classmethod def _executables(cls, interpreter): host = Path(interpreter.system_executable) targets = sorted(f"{name}{PyPy.suffix}" for name in cls.exe_names(interpreter)) yield host, targets, RefMust.NA, RefWhen.ANY @classmethod def executables(cls, interpreter): yield from super().sources(interpreter) @classmethod def exe_names(cls, interpreter): return { cls.exe_stem(), "python", f"python{interpreter.version_info.major}", f"python{interpreter.version_info.major}.{interpreter.version_info.minor}", } @classmethod def sources(cls, interpreter): yield from cls.executables(interpreter) for host in cls._add_shared_libs(interpreter): yield PathRefToDest(host, dest=lambda self, s: self.bin_dir / s.name) @classmethod def _add_shared_libs(cls, interpreter): # https://bitbucket.org/pypy/pypy/issue/1922/future-proofing-virtualenv python_dir = Path(interpreter.system_executable).resolve().parent yield from cls._shared_libs(python_dir) @classmethod def _shared_libs(cls, python_dir): raise NotImplementedError __all__ = [ "PyPy", ] builtin/pypy/__init__.py 0000644 00000000000 15030253017 0011306 0 ustar 00 builtin/__init__.py 0000644 00000000000 15030253017 0010305 0 ustar 00 store.py 0000644 00000001233 15030253017 0006245 0 ustar 00 from __future__ import annotations from pathlib import Path def handle_store_python(meta, interpreter): if is_store_python(interpreter): meta.symlink_error = "Windows Store Python does not support virtual environments via symlink" return meta def is_store_python(interpreter): parts = Path(interpreter.system_executable).parts return ( len(parts) > 4 # noqa: PLR2004 and parts[-4] == "Microsoft" and parts[-3] == "WindowsApps" and parts[-2].startswith("PythonSoftwareFoundation.Python.3.") and parts[-1].startswith("python") ) __all__ = [ "handle_store_python", "is_store_python", ] venv.py 0000644 00000007150 15030253017 0006073 0 ustar 00 from __future__ import annotations import logging from copy import copy from virtualenv.create.via_global_ref.store import handle_store_python from virtualenv.discovery.py_info import PythonInfo from virtualenv.util.error import ProcessCallFailedError from virtualenv.util.path import ensure_dir from virtualenv.util.subprocess import run_cmd from .api import ViaGlobalRefApi, ViaGlobalRefMeta from .builtin.cpython.mac_os import CPython3macOsBrew from .builtin.pypy.pypy3 import Pypy3Windows LOGGER = logging.getLogger(__name__) class Venv(ViaGlobalRefApi): def __init__(self, options, interpreter) -> None: self.describe = options.describe super().__init__(options, interpreter) current = PythonInfo.current() self.can_be_inline = interpreter is current and interpreter.executable == interpreter.system_executable self._context = None def _args(self): return super()._args() + ([("describe", self.describe.__class__.__name__)] if self.describe else []) @classmethod def can_create(cls, interpreter): if interpreter.has_venv: if CPython3macOsBrew.can_describe(interpreter): return CPython3macOsBrew.setup_meta(interpreter) meta = ViaGlobalRefMeta() if interpreter.platform == "win32": meta = handle_store_python(meta, interpreter) return meta return None def create(self): if self.can_be_inline: self.create_inline() else: self.create_via_sub_process() for lib in self.libs: ensure_dir(lib) super().create() self.executables_for_win_pypy_less_v37() def executables_for_win_pypy_less_v37(self): """ PyPy <= 3.6 (v7.3.3) for Windows contains only pypy3.exe and pypy3w.exe Venv does not handle non-existing exe sources, e.g. python.exe, so this patch does it. """ # noqa: D205 creator = self.describe if isinstance(creator, Pypy3Windows) and creator.less_v37: for exe in creator.executables(self.interpreter): exe.run(creator, self.symlinks) def create_inline(self): from venv import EnvBuilder # noqa: PLC0415 builder = EnvBuilder( system_site_packages=self.enable_system_site_package, clear=False, symlinks=self.symlinks, with_pip=False, ) builder.create(str(self.dest)) def create_via_sub_process(self): cmd = self.get_host_create_cmd() LOGGER.info("using host built-in venv to create via %s", " ".join(cmd)) code, out, err = run_cmd(cmd) if code != 0: raise ProcessCallFailedError(code, out, err, cmd) def get_host_create_cmd(self): cmd = [self.interpreter.system_executable, "-m", "venv", "--without-pip"] if self.enable_system_site_package: cmd.append("--system-site-packages") cmd.extend(("--symlinks" if self.symlinks else "--copies", str(self.dest))) return cmd def set_pyenv_cfg(self): # prefer venv options over ours, but keep our extra venv_content = copy(self.pyenv_cfg.refresh()) super().set_pyenv_cfg() self.pyenv_cfg.update(venv_content) def __getattribute__(self, item): describe = object.__getattribute__(self, "describe") if describe is not None and hasattr(describe, item): element = getattr(describe, item) if not callable(element) or item == "script": return element return object.__getattribute__(self, item) __all__ = [ "Venv", ] api.py 0000644 00000010300 15030253017 0005655 0 ustar 00 from __future__ import annotations import logging import os from abc import ABC from pathlib import Path from virtualenv.create.creator import Creator, CreatorMeta from virtualenv.info import fs_supports_symlink LOGGER = logging.getLogger(__name__) class ViaGlobalRefMeta(CreatorMeta): def __init__(self) -> None: super().__init__() self.copy_error = None self.symlink_error = None if not fs_supports_symlink(): self.symlink_error = "the filesystem does not supports symlink" @property def can_copy(self): return not self.copy_error @property def can_symlink(self): return not self.symlink_error class ViaGlobalRefApi(Creator, ABC): def __init__(self, options, interpreter) -> None: super().__init__(options, interpreter) self.symlinks = self._should_symlink(options) self.enable_system_site_package = options.system_site @staticmethod def _should_symlink(options): # Priority of where the option is set to follow the order: CLI, env var, file, hardcoded. # If both set at same level prefers copy over symlink. copies, symlinks = getattr(options, "copies", False), getattr(options, "symlinks", False) copy_src, sym_src = options.get_source("copies"), options.get_source("symlinks") for level in ["cli", "env var", "file", "default"]: s_opt = symlinks if sym_src == level else None c_opt = copies if copy_src == level else None if s_opt is True and c_opt is True: return False if s_opt is True: return True if c_opt is True: return False return False # fallback to copy @classmethod def add_parser_arguments(cls, parser, interpreter, meta, app_data): super().add_parser_arguments(parser, interpreter, meta, app_data) parser.add_argument( "--system-site-packages", default=False, action="store_true", dest="system_site", help="give the virtual environment access to the system site-packages dir", ) if not meta.can_symlink and not meta.can_copy: msg = "neither symlink or copy method supported" raise RuntimeError(msg) group = parser.add_mutually_exclusive_group() if meta.can_symlink: group.add_argument( "--symlinks", default=True, action="store_true", dest="symlinks", help="try to use symlinks rather than copies, when symlinks are not the default for the platform", ) if meta.can_copy: group.add_argument( "--copies", "--always-copy", default=not meta.can_symlink, action="store_true", dest="copies", help="try to use copies rather than symlinks, even when symlinks are the default for the platform", ) def create(self): self.install_patch() def install_patch(self): text = self.env_patch_text() if text: pth = self.purelib / "_virtualenv.pth" LOGGER.debug("create virtualenv import hook file %s", pth) pth.write_text("import _virtualenv", encoding="utf-8") dest_path = self.purelib / "_virtualenv.py" LOGGER.debug("create %s", dest_path) dest_path.write_text(text, encoding="utf-8") def env_patch_text(self): """Patch the distutils package to not be derailed by its configuration files.""" with self.app_data.ensure_extracted(Path(__file__).parent / "_virtualenv.py") as resolved_path: text = resolved_path.read_text(encoding="utf-8") return text.replace('"__SCRIPT_DIR__"', repr(os.path.relpath(str(self.script_dir), str(self.purelib)))) def _args(self): return [*super()._args(), ("global", self.enable_system_site_package)] def set_pyenv_cfg(self): super().set_pyenv_cfg() self.pyenv_cfg["include-system-site-packages"] = "true" if self.enable_system_site_package else "false" __all__ = [ "ViaGlobalRefApi", "ViaGlobalRefMeta", ] _virtualenv.py 0000644 00000010533 15030253017 0007452 0 ustar 00 """Patches that are applied at runtime to the virtual environment.""" from __future__ import annotations import os import sys VIRTUALENV_PATCH_FILE = os.path.join(__file__) def patch_dist(dist): """ Distutils allows user to configure some arguments via a configuration file: https://docs.python.org/3/install/index.html#distutils-configuration-files. Some of this arguments though don't make sense in context of the virtual environment files, let's fix them up. """ # noqa: D205 # we cannot allow some install config as that would get packages installed outside of the virtual environment old_parse_config_files = dist.Distribution.parse_config_files def parse_config_files(self, *args, **kwargs): result = old_parse_config_files(self, *args, **kwargs) install = self.get_option_dict("install") if "prefix" in install: # the prefix governs where to install the libraries install["prefix"] = VIRTUALENV_PATCH_FILE, os.path.abspath(sys.prefix) for base in ("purelib", "platlib", "headers", "scripts", "data"): key = f"install_{base}" if key in install: # do not allow global configs to hijack venv paths install.pop(key, None) return result dist.Distribution.parse_config_files = parse_config_files # Import hook that patches some modules to ignore configuration values that break package installation in case # of virtual environments. _DISTUTILS_PATCH = "distutils.dist", "setuptools.dist" # https://docs.python.org/3/library/importlib.html#setting-up-an-importer class _Finder: """A meta path finder that allows patching the imported distutils modules.""" fullname = None # lock[0] is threading.Lock(), but initialized lazily to avoid importing threading very early at startup, # because there are gevent-based applications that need to be first to import threading by themselves. # See https://github.com/pypa/virtualenv/issues/1895 for details. lock = [] # noqa: RUF012 def find_spec(self, fullname, path, target=None): # noqa: ARG002 if fullname in _DISTUTILS_PATCH and self.fullname is None: # noqa: PLR1702 # initialize lock[0] lazily if len(self.lock) == 0: import threading # noqa: PLC0415 lock = threading.Lock() # there is possibility that two threads T1 and T2 are simultaneously running into find_spec, # observing .lock as empty, and further going into hereby initialization. However due to the GIL, # list.append() operation is atomic and this way only one of the threads will "win" to put the lock # - that every thread will use - into .lock[0]. # https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe self.lock.append(lock) from functools import partial # noqa: PLC0415 from importlib.util import find_spec # noqa: PLC0415 with self.lock[0]: self.fullname = fullname try: spec = find_spec(fullname, path) if spec is not None: # https://www.python.org/dev/peps/pep-0451/#how-loading-will-work is_new_api = hasattr(spec.loader, "exec_module") func_name = "exec_module" if is_new_api else "load_module" old = getattr(spec.loader, func_name) func = self.exec_module if is_new_api else self.load_module if old is not func: try: # noqa: SIM105 setattr(spec.loader, func_name, partial(func, old)) except AttributeError: pass # C-Extension loaders are r/o such as zipimporter with <3.7 return spec finally: self.fullname = None return None @staticmethod def exec_module(old, module): old(module) if module.__name__ in _DISTUTILS_PATCH: patch_dist(module) @staticmethod def load_module(old, name): module = old(name) if module.__name__ in _DISTUTILS_PATCH: patch_dist(module) return module sys.meta_path.insert(0, _Finder()) __init__.py 0000644 00000000000 15030253017 0006637 0 ustar 00
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings