File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/create.tar
Back
__pycache__/pyenv_cfg.cpython-310.pyc 0000644 00000005221 15030251563 0013435 0 ustar 00 o }h! � @ sJ d dl mZ d dlZd dlZd dlmZ e�e�ZG dd� d�Z dgZ dS )� )� annotationsN)� OrderedDictc @ sx e Zd Zd dd�Zedd� �Zedd� �Zed d � �Zd d � Z d d� Z d dd�Z dd� Z d dd�Z dd� Zd dd�ZdS ) �PyEnvCfg�return�Nonec C s || _ || _d S �N)�content�path)�selfr r � r �F/usr/local/lib/python3.10/dist-packages/virtualenv/create/pyenv_cfg.py�__init__ s zPyEnvCfg.__init__c C s | � |d �S )Nz pyvenv.cfg)� from_file)�cls�folderr r r � from_folder s zPyEnvCfg.from_folderc C s" |� � r | �|�nt� }t||�S r )�exists� _read_valuesr r )r r r r r r r s zPyEnvCfg.from_filec C sV t � }| jdd��� D ] }|�d�}|d |� �� }||d d � �� }|||< q |S )N�utf-8��encoding�=� )r � read_text� splitlines�index�strip)r r �line� equals_at�key�valuer r r r s zPyEnvCfg._read_valuesc C s� t �d| j� d}| j�� D ])\}}|r tj�|�r tj�|�n|}|� d|� �}t �d|� ||7 }|d7 }q| jj|dd� d S )Nzwrite %s� z = z %s� r r ) �LOGGER�debugr r �items�osr �realpath� write_text)r �textr r �normalized_valuer r r r �write" s zPyEnvCfg.writec C s | � | j�| _| jS r )r r r �r r r r �refresh- s zPyEnvCfg.refreshc C s || j |< d S r �r )r r r r r r � __setitem__1 s zPyEnvCfg.__setitem__c C s | j | S r r. )r r r r r � __getitem__4 � zPyEnvCfg.__getitem__�boolc C s || j v S r r. )r �itemr r r � __contains__7 r1 zPyEnvCfg.__contains__c C s | j �|� | S r )r �update)r �otherr r r r5 : s zPyEnvCfg.update�strc C s | j j� d| j� d�S )Nz(path=�))� __class__�__name__r r, r r r �__repr__> s zPyEnvCfg.__repr__N)r r )r r2 )r r7 )r: � __module__� __qualname__r � classmethodr r � staticmethodr r+ r- r/ r0 r4 r5 r; r r r r r s r ) � __future__r �loggingr& � collectionsr � getLoggerr: r# r �__all__r r r r �<module> s 9� __pycache__/__init__.cpython-310.pyc 0000644 00000000242 15030251563 0013212 0 ustar 00 o }h � @ s d S )N� r r r �E/usr/local/lib/python3.10/dist-packages/virtualenv/create/__init__.py�<module> s __pycache__/debug.cpython-310.pyc 0000644 00000004512 15030251563 0012545 0 ustar 00 o }hM � @ sF d Z ddlmZ ddlZdd� Zdd� Zdd � Zed kr!e� dS dS ) z=Inspect a target Python interpreter virtual environment wise.� )� annotationsNc C sT | d u rd S t | ttf�s t | t�rt| �ntt| ��} t | t�r(| �t�� �} | S )N)� isinstance�str�bytes�type�repr�decode�sys�getfilesystemencoding��value� r �B/usr/local/lib/python3.10/dist-packages/virtualenv/create/debug.py� encode_path s r c C s dd� | D �S )Nc S s g | ]}t |��qS r )r )�.0�ir r r � <listcomp> s z$encode_list_path.<locals>.<listcomp>r r r r r �encode_list_path s r c C s� zddl m} W n ty t} Y nw | d| � fg�}d}|D ]}tt|d�}t|t�r1t|�nt |�}||d |< q t� � |d d< ttj dd�|d d< tj |d < zddl }t|d t|d d��}t |� �|d < W n tyt Y nw ddl}t|�|d < z ddl}t|�|d< W n ty� } z t| �|d< W Y d} ~ nd} ~ ww z ddl} t| �|d< W n ty� } z t| �|d< W Y d} ~ nd} ~ ww z ddl} t| �|d< W n ty� } z t| �|d< W Y d} ~ nd} ~ ww z ddl} t| �|d< W n t�y } z t| �|d< W Y d} ~ dS d} ~ ww z| j|dd�} tj �| � W dS ttf�yH } ztj�t| �� tj �t|�� td��d} ~ ww )z/Print debug data about the virtual environment.r )� OrderedDictr ) � executable�_base_executable�prefix� base_prefix� real_prefix� exec_prefix�base_exec_prefix�path� meta_pathN� fs_encoding�encoding� io_encoding�version�get_makefile_filename�_get_makefile_filename�makefile_filename�os�site�datetime�math�json� )�indent� )� collectionsr � ImportError�dict�getattrr r �listr r r �stdoutr! � sysconfigr% r r& r' r( r) �dumps�write� ValueError� TypeError�stderr� SystemExit)r �result� path_keys�keyr r3 �makefiler% r& � exceptionr' r( r) �contentr r r �run sx � � ����������r@ �__main__)�__doc__� __future__r r r r r@ �__name__r r r r �<module> s O � __pycache__/describe.cpython-310.pyc 0000644 00000010465 15030251563 0013243 0 ustar 00 o }hR � @ s� d dl mZ d dlmZ d dlmZ d dlmZ d dlm Z G dd� d�Z G dd � d e e�Z G d d � d e e�Z G d d � d e e�Z g d�ZdS )� )� annotations)�ABC)� OrderedDict)�Path)�IS_WINc @ s� e Zd ZdZer dndZd%dd�Zedd � �Zed d � �Z ed d � �Z edd� �Z edd� �Z edd� �Z edd� �Zedd� �Zdd� Zedd� �Zed d � �Zed d � �Zed d!� �Zd"d#� Zd$S )&�Describez`Given a host interpreter tell us information about what the created interpreter might look like.z.exe� �return�Nonec C s( || _ || _d | _d | _d | _d | _d S �N)� interpreter�dest�_stdlib�_stdlib_platform�_system_stdlib� _conf_vars)�selfr r � r �E/usr/local/lib/python3.10/dist-packages/virtualenv/create/describe.py�__init__ s zDescribe.__init__c C s | j S r )� script_dir�r r r r �bin_dir s zDescribe.bin_dirc C � | j | j�d� S )N�scripts�r r � install_pathr r r r r � zDescribe.script_dirc C r )N�purelibr r r r r r r zDescribe.purelibc C r )N�platlibr r r r r r # r zDescribe.platlibc C s t t| jd f| jd ff��� �S r )�listr r r �keysr r r r �libs' s z Describe.libsc C �( | j d u rt| jjd| jd��| _ | j S )N�stdlib�� config_var)r r r �sysconfig_path� _config_varsr r r r r$ + � zDescribe.stdlibc C r# )N� platstdlibr% )r r r r' r( r r r r �stdlib_platform1 r) zDescribe.stdlib_platformc C s | j d u r | �| j�| _ | j S r )r �_calc_config_varsr r r r r r( 7 s zDescribe._config_varsc s � j j}� �fdd�|�� D �S )Nc s0 i | ]\}}||d ur|� � jj�r�n|�qS r )� startswithr �prefix)�.0�k�v�r �tor r � <dictcomp>? s 0 z.Describe._calc_config_vars.<locals>.<dictcomp>)r �sysconfig_vars�items)r r3 �sys_varsr r2 r r, = s zDescribe._calc_config_varsc C s dS )z.Knows means it knows how the output will look.Tr ��clsr r r r � can_describeA � zDescribe.can_describec C s | j jd S )N���)r �partsr r r r �env_nameF s zDescribe.env_namec C s | j | �� � | j� � S r )r �exe_stem�suffixr r r r �exeJ � z Describe.exec C s t �)zcExecutable name without suffix - there seems to be no standard way to get this without creating it.)�NotImplementedError)r9 r r r r? N r; zDescribe.exe_stemc C s | j |� | j� � S r )r r@ )r �namer r r �scriptS s zDescribe.scriptN)r r )�__name__� __module__� __qualname__�__doc__r r@ r �propertyr r r r r" r$ r+ r( r, � classmethodr: r> rA r? rE r r r r r s< r c � e Zd Ze� fdd��Z� ZS )�Python3Supportsc s |j jdko t� �|�S )N� )� version_info�major�superr: r8 �� __class__r r r: X rB z Python3Supports.can_describe�rF rG rH rK r: � __classcell__r r rR r rM W � rM c rL )� PosixSupportsc � |j dko t� �|�S )N�posix��osrQ r: r8 rR r r r: ^ � zPosixSupports.can_describerT r r rR r rW ] rV rW c rL )�WindowsSupportsc rX )N�ntrZ r8 rR r r r: d r\ z WindowsSupports.can_describerT r r rR r r] c rV r] )r rW rM r] N)� __future__r �abcr � collectionsr �pathlibr �virtualenv.infor r rM rW r] �__all__r r r r �<module> s M __pycache__/creator.cpython-310.pyc 0000644 00000020311 15030251563 0013111 0 ustar 00 o }h�# � @ s d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZm Z d dl m Z d dl m Z d dlmZ d dlmZ d dlmZ d d lmZ d d lmZ d d lmZ d d lmZ eej � e ��j Z e d Z!e�"e#�Z$G dd� d�Z%G dd� de�Z&dd� Z'ddgZ(dS )� )� annotationsN)�ABC�abstractmethod)�ArgumentTypeError)� literal_eval)� OrderedDict)�Path)�LogCmd)� safe_delete)�run_cmd)� __version__� )�PyEnvCfgzdebug.pyc @ s e Zd Zddd�ZdS )� CreatorMeta�return�Nonec C s d | _ d S �N)�error��self� r �D/usr/local/lib/python3.10/dist-packages/virtualenv/create/creator.py�__init__ s zCreatorMeta.__init__N�r r )�__name__� __module__� __qualname__r r r r r r s r c @ s� e Zd ZdZd dd�Zd!dd�Zd d � Zed d � �Zed d� �Z e dd� �Z edd� �Z dd� Z dd� Zdd� Zdd� Zedd � �Zed d � �Zd S )"�CreatorzFA class that given a python Interpreter creates a virtual environment.r r c C sJ || _ d| _t|j�| _|j| _|j| _t�| j�| _|j | _ |j | _ dS )z� Construct a new virtual environment creator. :param options: the CLI option as parsed from :meth:`add_parser_arguments` :param interpreter: the interpreter to create virtual environment from N) � interpreter�_debugr �dest�clear� no_vcs_ignorer � from_folder� pyenv_cfg�app_data�env)r �optionsr r r r r " s zCreator.__init__�strc C s( | j j� dd�dd� | �� D ��� d�S )N�(z, c s s" � | ] \}}|� d |� �V qdS )�=Nr )�.0�k�vr r r � <genexpr>3 s � z#Creator.__repr__.<locals>.<genexpr>�))� __class__r �join�_argsr r r r �__repr__2 s (zCreator.__repr__c C s dt | j�fd| jfd| jfgS )Nr r! r" )r( r r! r" r r r r r2 5 s �z Creator._argsc C s dS )a Determine if we can create a virtual environment. :param interpreter: the interpreter in question :return: ``None`` if we can't create, any other object otherwise that will be forwarded to :meth:`add_parser_arguments` Tr )�clsr r r r � can_create< s zCreator.can_createc C s> |j dd| jd� |j dddddd � |j d d dd dd � d S )a' Add CLI arguments for the creator. :param parser: the CLI parser :param app_data: the application data folder :param interpreter: the interpreter we're asked to create virtual environment for :param meta: value as returned by :meth:`can_create` r z!directory to create virtualenv at)�help�typez--clearr! � store_truezZremove the destination directory if exist before starting (will overwrite files otherwise)F)r �actionr6 �defaultz--no-vcs-ignorer" z>don't create VCS ignore directive in the destination directoryN)� add_argument� validate_dest)r4 �parserr �metar% r r r �add_parser_argumentsG s& �� �z Creator.add_parser_argumentsc C s t �)z)Perform the virtual environment creation.)�NotImplementedErrorr r r r �createe s zCreator.createc C s~ dd� }t �� }t� }|dkrddini }t|�D ]%}z|j|fi |���|�}||kr.W qt|�� ty> d||< Y qw |rWd�|�� �}d|� d |�d |��} t | ��t j |v rjd |�d t j � d �} t | ��t |�} | � � r�| �� r�d| � d�} t | ��t t j�t| ����� } | } | r�| � � r�t �t| �t j�r� t| �S || | � | j| j} } | | kr�|| | � | } | s�t| �S )zBNo path separator in the path, valid chars and must be write-able.c S s6 t tj�|j| jg�� }d| �|�� d|� �}t|��)N�the destination z is not write-able at )r �os�path� commonprefix�parts� relative_tor )r �value�common�msgr r r �non_write_ablen s z-Creator.validate_dest.<locals>.non_write_able�mbcs�errors�ignoreN� zthe file system codec (z) cannot handle characters z within z destination z& must not contain the path separator (z,) as this would break the activation scriptsrB z already exists and is a file)�sys�getfilesystemencodingr r( �encode�decode� ValueErrorr1 �keysr rC �pathsepr �exists�is_filerD �abspath�resolve�access�W_OK�parent�name)r4 � raw_valuerK �encoding�refused�kwargs�char�trip�badrJ rH r �base�_r r r r< j sN � � � � zCreator.validate_destc C sV | j �� r| jrt�d| j � t| j � | �� | �� | �� | j s)| � � d S d S )Nz delete %s) r rW r! �LOGGER�debugr rA �add_cachedir_tag� set_pyenv_cfgr" �setup_ignore_vcsr r r r �run� s �z Creator.runc C s6 | j d }|�� st�d��� }|j|dd� dS dS )zBGenerate a file indicating that this is not meant to be backed up.z CACHEDIR.TAGa Signature: 8a477f597d28d172789f06886806bc55 # This file is a cache directory tag created by Python virtualenv. # For information about cache directory tags, see: # https://bford.info/cachedir/ �utf-8�r` N)r rW �textwrap�dedent�strip� write_text)r �cachedir_tag_file�cachedir_tag_textr r r rj � s ��zCreator.add_cachedir_tagc C sb t � | j_tj�tj�| jj��| jd< | jj | jd< d� dd� | jj D ��| jd< t | jd< d S )N�home�implementation�.c s s � | ]}t |�V qd S r )r( )r+ �ir r r r. � s � z(Creator.set_pyenv_cfg.<locals>.<genexpr>� version_info� virtualenv) r r$ �contentrC rD �dirnamerY r �system_executablerw r1 rz r r r r r rk � s zCreator.set_pyenv_cfgc C s( | j d }|�� s|jddd� dS dS )z9Generate ignore instructions for version control systems.z .gitignorez(# created by virtualenv automatically * rn ro N)r rW rs )r � git_ignorer r r rl � s �zCreator.setup_ignore_vcsc C s4 | j du r| jdurt| j| �� | j| j�| _ | j S )zb:return: debug information about the virtual environment (only valid after :meth:`create` has run)N)r �exe�get_env_debug_info� debug_scriptr% r& r r r r ri � s z Creator.debugc C s t S r )� DEBUG_SCRIPTr r r r r� � s zCreator.debug_scriptNr )r r( )r r r �__doc__r r3 r2 � classmethodr5 r? r rA r< rm rj rk rl �propertyri � staticmethodr� r r r r r s* 1 r c C s |� � }|�dd � |�|�� }t| �t|�g}t�dt|�� t|�\}}}W d � n1 s1w Y z(|dkrR|rBt|�} n|dkrNd|v rNt |��t |��t � |�} |r]|| d< W n t yy } z|||t | �d�W Y d } ~ S d } ~ ww d| v r�d | d v r�| d d d= | S ) N� PYTHONPATHz debug via %rr � �file�err)�outr� � returncode� exceptionrP rD )�copy�pop�ensure_extractedr( rh ri r r r �OSError� Exception�json�loads�repr) �env_exer� r% r& �debug_script_extracted�cmd�coder� r� �resultr� r r r r� � s2 � � ��r� ))� __future__r r� �loggingrC rP rp �abcr r �argparser �astr � collectionsr �pathlibr �#virtualenv.discovery.cached_py_infor �virtualenv.util.pathr �virtualenv.util.subprocessr �virtualenv.versionr r$ r rD rY �__file__r] �HEREr� � getLoggerr rh r r r� �__all__r r r r �<module> s4 3 � creator.py 0000644 00000021765 15030251563 0006570 0 ustar 00 from __future__ import annotations import json import logging import os import sys import textwrap from abc import ABC, abstractmethod from argparse import ArgumentTypeError from ast import literal_eval from collections import OrderedDict from pathlib import Path from virtualenv.discovery.cached_py_info import LogCmd from virtualenv.util.path import safe_delete from virtualenv.util.subprocess import run_cmd from virtualenv.version import __version__ from .pyenv_cfg import PyEnvCfg HERE = Path(os.path.abspath(__file__)).parent DEBUG_SCRIPT = HERE / "debug.py" LOGGER = logging.getLogger(__name__) class CreatorMeta: def __init__(self) -> None: self.error = None class Creator(ABC): """A class that given a python Interpreter creates a virtual environment.""" def __init__(self, options, interpreter) -> None: """ Construct a new virtual environment creator. :param options: the CLI option as parsed from :meth:`add_parser_arguments` :param interpreter: the interpreter to create virtual environment from """ self.interpreter = interpreter self._debug = None self.dest = Path(options.dest) self.clear = options.clear self.no_vcs_ignore = options.no_vcs_ignore self.pyenv_cfg = PyEnvCfg.from_folder(self.dest) self.app_data = options.app_data self.env = options.env def __repr__(self) -> str: return f"{self.__class__.__name__}({', '.join(f'{k}={v}' for k, v in self._args())})" def _args(self): return [ ("dest", str(self.dest)), ("clear", self.clear), ("no_vcs_ignore", self.no_vcs_ignore), ] @classmethod def can_create(cls, interpreter): # noqa: ARG003 """ Determine if we can create a virtual environment. :param interpreter: the interpreter in question :return: ``None`` if we can't create, any other object otherwise that will be forwarded to \ :meth:`add_parser_arguments` """ return True @classmethod def add_parser_arguments(cls, parser, interpreter, meta, app_data): # noqa: ARG003 """ Add CLI arguments for the creator. :param parser: the CLI parser :param app_data: the application data folder :param interpreter: the interpreter we're asked to create virtual environment for :param meta: value as returned by :meth:`can_create` """ parser.add_argument( "dest", help="directory to create virtualenv at", type=cls.validate_dest, ) parser.add_argument( "--clear", dest="clear", action="store_true", help="remove the destination directory if exist before starting (will overwrite files otherwise)", default=False, ) parser.add_argument( "--no-vcs-ignore", dest="no_vcs_ignore", action="store_true", help="don't create VCS ignore directive in the destination directory", default=False, ) @abstractmethod def create(self): """Perform the virtual environment creation.""" raise NotImplementedError @classmethod def validate_dest(cls, raw_value): # noqa: C901 """No path separator in the path, valid chars and must be write-able.""" def non_write_able(dest, value): common = Path(*os.path.commonprefix([value.parts, dest.parts])) msg = f"the destination {dest.relative_to(common)} is not write-able at {common}" raise ArgumentTypeError(msg) # the file system must be able to encode # note in newer CPython this is always utf-8 https://www.python.org/dev/peps/pep-0529/ encoding = sys.getfilesystemencoding() refused = OrderedDict() kwargs = {"errors": "ignore"} if encoding != "mbcs" else {} for char in str(raw_value): try: trip = char.encode(encoding, **kwargs).decode(encoding) if trip == char: continue raise ValueError(trip) # noqa: TRY301 except ValueError: refused[char] = None if refused: bad = "".join(refused.keys()) msg = f"the file system codec ({encoding}) cannot handle characters {bad!r} within {raw_value!r}" raise ArgumentTypeError(msg) if os.pathsep in raw_value: msg = ( f"destination {raw_value!r} must not contain the path separator ({os.pathsep})" f" as this would break the activation scripts" ) raise ArgumentTypeError(msg) value = Path(raw_value) if value.exists() and value.is_file(): msg = f"the destination {value} already exists and is a file" raise ArgumentTypeError(msg) dest = Path(os.path.abspath(str(value))).resolve() # on Windows absolute does not imply resolve so use both value = dest while dest: if dest.exists(): if os.access(str(dest), os.W_OK): break non_write_able(dest, value) base, _ = dest.parent, dest.name if base == dest: non_write_able(dest, value) # pragma: no cover dest = base return str(value) def run(self): if self.dest.exists() and self.clear: LOGGER.debug("delete %s", self.dest) safe_delete(self.dest) self.create() self.add_cachedir_tag() self.set_pyenv_cfg() if not self.no_vcs_ignore: self.setup_ignore_vcs() def add_cachedir_tag(self): """Generate a file indicating that this is not meant to be backed up.""" cachedir_tag_file = self.dest / "CACHEDIR.TAG" if not cachedir_tag_file.exists(): cachedir_tag_text = textwrap.dedent(""" Signature: 8a477f597d28d172789f06886806bc55 # This file is a cache directory tag created by Python virtualenv. # For information about cache directory tags, see: # https://bford.info/cachedir/ """).strip() cachedir_tag_file.write_text(cachedir_tag_text, encoding="utf-8") def set_pyenv_cfg(self): self.pyenv_cfg.content = OrderedDict() self.pyenv_cfg["home"] = os.path.dirname(os.path.abspath(self.interpreter.system_executable)) self.pyenv_cfg["implementation"] = self.interpreter.implementation self.pyenv_cfg["version_info"] = ".".join(str(i) for i in self.interpreter.version_info) self.pyenv_cfg["virtualenv"] = __version__ def setup_ignore_vcs(self): """Generate ignore instructions for version control systems.""" # mark this folder to be ignored by VCS, handle https://www.python.org/dev/peps/pep-0610/#registered-vcs git_ignore = self.dest / ".gitignore" if not git_ignore.exists(): git_ignore.write_text("# created by virtualenv automatically\n*\n", encoding="utf-8") # Mercurial - does not support the .hgignore file inside a subdirectory directly, but only if included via the # subinclude directive from root, at which point on might as well ignore the directory itself, see # https://www.selenic.com/mercurial/hgignore.5.html for more details # Bazaar - does not support ignore files in sub-directories, only at root level via .bzrignore # Subversion - does not support ignore files, requires direct manipulation with the svn tool @property def debug(self): """:return: debug information about the virtual environment (only valid after :meth:`create` has run)""" if self._debug is None and self.exe is not None: self._debug = get_env_debug_info(self.exe, self.debug_script(), self.app_data, self.env) return self._debug @staticmethod def debug_script(): return DEBUG_SCRIPT def get_env_debug_info(env_exe, debug_script, app_data, env): env = env.copy() env.pop("PYTHONPATH", None) with app_data.ensure_extracted(debug_script) as debug_script_extracted: cmd = [str(env_exe), str(debug_script_extracted)] LOGGER.debug("debug via %r", LogCmd(cmd)) code, out, err = run_cmd(cmd) try: if code != 0: if out: result = literal_eval(out) else: if code == 2 and "file" in err: # noqa: PLR2004 # Re-raise FileNotFoundError from `run_cmd()` raise OSError(err) # noqa: TRY301 raise Exception(err) # noqa: TRY002, TRY301 else: result = json.loads(out) if err: result["err"] = err except Exception as exception: # noqa: BLE001 return {"out": out, "err": err, "returncode": code, "exception": repr(exception)} if "sys" in result and "path" in result["sys"]: del result["sys"]["path"][0] return result __all__ = [ "Creator", "CreatorMeta", ] via_global_ref/__pycache__/_virtualenv.cpython-310.pyc 0000644 00000005305 15030251563 0016751 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 = via_global_ref/__pycache__/store.cpython-310.pyc 0000644 00000001535 15030251563 0015550 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 � via_global_ref/__pycache__/__init__.cpython-310.pyc 0000644 00000000261 15030251563 0016146 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 via_global_ref/__pycache__/venv.cpython-310.pyc 0000644 00000007662 15030251563 0015401 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� via_global_ref/__pycache__/api.cpython-310.pyc 0000644 00000010562 15030251563 0015165 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� via_global_ref/builtin/ref.py 0000644 00000012471 15030251563 0012300 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", ] via_global_ref/builtin/cpython/cpython3.py 0000644 00000011265 15030251563 0014757 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", ] via_global_ref/builtin/cpython/__pycache__/__init__.cpython-310.pyc 0000644 00000000301 15030251563 0021273 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 via_global_ref/builtin/cpython/__pycache__/mac_os.cpython-310.pyc 0000644 00000027063 15030251563 0021013 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* % % via_global_ref/builtin/cpython/__pycache__/cpython3.cpython-310.pyc 0000644 00000011720 15030251563 0021312 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 via_global_ref/builtin/cpython/__pycache__/common.cpython-310.pyc 0000644 00000006377 15030251563 0021047 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" � via_global_ref/builtin/cpython/mac_os.py 0000644 00000026625 15030251563 0014457 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", ] via_global_ref/builtin/cpython/common.py 0000644 00000004721 15030251563 0014477 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", ] via_global_ref/builtin/cpython/__init__.py 0000644 00000000000 15030251563 0014730 0 ustar 00 via_global_ref/builtin/via_global_self_do.py 0000644 00000010516 15030251563 0015314 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", ] via_global_ref/builtin/__pycache__/builtin_way.cpython-310.pyc 0000644 00000001626 15030251563 0020411 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 � via_global_ref/builtin/__pycache__/__init__.cpython-310.pyc 0000644 00000000271 15030251563 0017615 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 via_global_ref/builtin/__pycache__/via_global_self_do.cpython-310.pyc 0000644 00000011217 15030251563 0021652 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 ^� via_global_ref/builtin/__pycache__/ref.cpython-310.pyc 0000644 00000014204 15030251563 0016633 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 @ " via_global_ref/builtin/builtin_way.py 0000644 00000001010 15030251563 0014035 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", ] via_global_ref/builtin/graalpy/__pycache__/__init__.cpython-310.pyc 0000644 00000007511 15030251563 0021260 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 � via_global_ref/builtin/graalpy/__init__.py 0000644 00000005652 15030251563 0014725 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", ] via_global_ref/builtin/pypy/__pycache__/__init__.cpython-310.pyc 0000644 00000000276 15030251563 0020623 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 via_global_ref/builtin/pypy/__pycache__/pypy3.cpython-310.pyc 0000644 00000004750 15030251563 0020151 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 # via_global_ref/builtin/pypy/__pycache__/common.cpython-310.pyc 0000644 00000004640 15030251563 0020353 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 *� via_global_ref/builtin/pypy/pypy3.py 0000644 00000004676 15030251563 0013621 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", ] via_global_ref/builtin/pypy/common.py 0000644 00000003264 15030251563 0014015 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", ] via_global_ref/builtin/pypy/__init__.py 0000644 00000000000 15030251563 0014245 0 ustar 00 via_global_ref/builtin/__init__.py 0000644 00000000000 15030251563 0013244 0 ustar 00 via_global_ref/store.py 0000644 00000001233 15030251563 0011204 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", ] via_global_ref/venv.py 0000644 00000007150 15030251563 0011032 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", ] via_global_ref/api.py 0000644 00000010300 15030251563 0010614 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", ] via_global_ref/_virtualenv.py 0000644 00000010533 15030251563 0012411 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()) via_global_ref/__init__.py 0000644 00000000000 15030251563 0011576 0 ustar 00 pyenv_cfg.py 0000644 00000003441 15030251563 0007100 0 ustar 00 from __future__ import annotations import logging import os from collections import OrderedDict LOGGER = logging.getLogger(__name__) class PyEnvCfg: def __init__(self, content, path) -> None: self.content = content self.path = path @classmethod def from_folder(cls, folder): return cls.from_file(folder / "pyvenv.cfg") @classmethod def from_file(cls, path): content = cls._read_values(path) if path.exists() else OrderedDict() return PyEnvCfg(content, path) @staticmethod def _read_values(path): content = OrderedDict() for line in path.read_text(encoding="utf-8").splitlines(): equals_at = line.index("=") key = line[:equals_at].strip() value = line[equals_at + 1 :].strip() content[key] = value return content def write(self): LOGGER.debug("write %s", self.path) text = "" for key, value in self.content.items(): normalized_value = os.path.realpath(value) if value and os.path.exists(value) else value line = f"{key} = {normalized_value}" LOGGER.debug("\t%s", line) text += line text += "\n" self.path.write_text(text, encoding="utf-8") def refresh(self): self.content = self._read_values(self.path) return self.content def __setitem__(self, key, value) -> None: self.content[key] = value def __getitem__(self, key): return self.content[key] def __contains__(self, item) -> bool: return item in self.content def update(self, other): self.content.update(other) return self def __repr__(self) -> str: return f"{self.__class__.__name__}(path={self.path})" __all__ = [ "PyEnvCfg", ] debug.py 0000644 00000006115 15030251563 0006207 0 ustar 00 """Inspect a target Python interpreter virtual environment wise.""" from __future__ import annotations import sys # built-in def encode_path(value): if value is None: return None if not isinstance(value, (str, bytes)): value = repr(value) if isinstance(value, type) else repr(type(value)) if isinstance(value, bytes): value = value.decode(sys.getfilesystemencoding()) return value def encode_list_path(value): return [encode_path(i) for i in value] def run(): """Print debug data about the virtual environment.""" try: from collections import OrderedDict # noqa: PLC0415 except ImportError: # pragma: no cover # this is possible if the standard library cannot be accessed OrderedDict = dict # pragma: no cover # noqa: N806 result = OrderedDict([("sys", OrderedDict())]) path_keys = ( "executable", "_base_executable", "prefix", "base_prefix", "real_prefix", "exec_prefix", "base_exec_prefix", "path", "meta_path", ) for key in path_keys: value = getattr(sys, key, None) value = encode_list_path(value) if isinstance(value, list) else encode_path(value) result["sys"][key] = value result["sys"]["fs_encoding"] = sys.getfilesystemencoding() result["sys"]["io_encoding"] = getattr(sys.stdout, "encoding", None) result["version"] = sys.version try: import sysconfig # noqa: PLC0415 # https://bugs.python.org/issue22199 makefile = getattr(sysconfig, "get_makefile_filename", getattr(sysconfig, "_get_makefile_filename", None)) result["makefile_filename"] = encode_path(makefile()) except ImportError: pass import os # landmark # noqa: PLC0415 result["os"] = repr(os) try: import site # site # noqa: PLC0415 result["site"] = repr(site) except ImportError as exception: # pragma: no cover result["site"] = repr(exception) # pragma: no cover try: import datetime # site # noqa: PLC0415 result["datetime"] = repr(datetime) except ImportError as exception: # pragma: no cover result["datetime"] = repr(exception) # pragma: no cover try: import math # site # noqa: PLC0415 result["math"] = repr(math) except ImportError as exception: # pragma: no cover result["math"] = repr(exception) # pragma: no cover # try to print out, this will validate if other core modules are available (json in this case) try: import json # noqa: PLC0415 result["json"] = repr(json) except ImportError as exception: result["json"] = repr(exception) else: try: content = json.dumps(result, indent=2) sys.stdout.write(content) except (ValueError, TypeError) as exception: # pragma: no cover sys.stderr.write(repr(exception)) sys.stdout.write(repr(result)) # pragma: no cover raise SystemExit(1) # noqa: B904 # pragma: no cover if __name__ == "__main__": run() describe.py 0000644 00000006122 15030251563 0006677 0 ustar 00 from __future__ import annotations from abc import ABC from collections import OrderedDict from pathlib import Path from virtualenv.info import IS_WIN class Describe: """Given a host interpreter tell us information about what the created interpreter might look like.""" suffix = ".exe" if IS_WIN else "" def __init__(self, dest, interpreter) -> None: self.interpreter = interpreter self.dest = dest self._stdlib = None self._stdlib_platform = None self._system_stdlib = None self._conf_vars = None @property def bin_dir(self): return self.script_dir @property def script_dir(self): return self.dest / self.interpreter.install_path("scripts") @property def purelib(self): return self.dest / self.interpreter.install_path("purelib") @property def platlib(self): return self.dest / self.interpreter.install_path("platlib") @property def libs(self): return list(OrderedDict(((self.platlib, None), (self.purelib, None))).keys()) @property def stdlib(self): if self._stdlib is None: self._stdlib = Path(self.interpreter.sysconfig_path("stdlib", config_var=self._config_vars)) return self._stdlib @property def stdlib_platform(self): if self._stdlib_platform is None: self._stdlib_platform = Path(self.interpreter.sysconfig_path("platstdlib", config_var=self._config_vars)) return self._stdlib_platform @property def _config_vars(self): if self._conf_vars is None: self._conf_vars = self._calc_config_vars(self.dest) return self._conf_vars def _calc_config_vars(self, to): sys_vars = self.interpreter.sysconfig_vars return {k: (to if v is not None and v.startswith(self.interpreter.prefix) else v) for k, v in sys_vars.items()} @classmethod def can_describe(cls, interpreter): # noqa: ARG003 """Knows means it knows how the output will look.""" return True @property def env_name(self): return self.dest.parts[-1] @property def exe(self): return self.bin_dir / f"{self.exe_stem()}{self.suffix}" @classmethod def exe_stem(cls): """Executable name without suffix - there seems to be no standard way to get this without creating it.""" raise NotImplementedError def script(self, name): return self.script_dir / f"{name}{self.suffix}" class Python3Supports(Describe, ABC): @classmethod def can_describe(cls, interpreter): return interpreter.version_info.major == 3 and super().can_describe(interpreter) # noqa: PLR2004 class PosixSupports(Describe, ABC): @classmethod def can_describe(cls, interpreter): return interpreter.os == "posix" and super().can_describe(interpreter) class WindowsSupports(Describe, ABC): @classmethod def can_describe(cls, interpreter): return interpreter.os == "nt" and super().can_describe(interpreter) __all__ = [ "Describe", "PosixSupports", "Python3Supports", "WindowsSupports", ] __init__.py 0000644 00000000000 15030251563 0006643 0 ustar 00
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings