File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/run.tar
Back
__pycache__/__init__.cpython-310.pyc 0000644 00000013440 15030371134 0013213 0 ustar 00 o }hd � @ s� d dl mZ d dlZd dlZd dlmZ d dlmZ d dlm Z d dl m Z m Z d dl mZ d dlmZ d d lmZ d d lmZ d d lmZ d d lmZ d dlmZ d dd�Zd dd�Z d!dd�Z d"dd�Z dd� Z dd� Z d d � Z!d d � Z"ddgZ#dS )#� )� annotationsN)�partial)� make_app_data)�VirtualEnvConfigParser)�LEVELS� setup_report)�Session)�manual_upgrade)� __version__� )�ActivationSelector)�CreatorSelector)� get_discover)�SeederSelectorTc C sR |du rt jn|}t| |||�}|� |�� W d � |S 1 s"w Y |S )a� Create a virtual environment given some command line interface arguments. :param args: the command line arguments :param options: passing in a ``VirtualEnvOptions`` object allows return of the parsed options :param setup_logging: ``True`` if setup logging handlers, ``False`` to use handlers already registered :param env: environment variables to use :return: the session object of the creation (its structure for now is experimental and might change on short notice) N)�os�environ�session_via_cli�run)�args�options� setup_logging�env� of_session� r �B/usr/local/lib/python3.10/dist-packages/virtualenv/run/__init__.py�cli_run s ��r c sb |du rt jn|}t| � ||�\}}|�| �� t� fdd�|D ��\}}}t� j� j|j|||�S )aq Create a virtualenv session (same as cli_run, but this does not perform the creation). Use this if you just want to query what the virtual environment would look like, but not actually create it. :param args: the command line arguments :param options: passing in a ``VirtualEnvOptions`` object allows return of the parsed options :param setup_logging: ``True`` if setup logging handlers, ``False`` to use handlers already registered :param env: environment variables to use :return: the session object of the creation (its structure for now is experimental and might change on short notice) Nc 3 s � | ]}|� � �V qd S �N)�create)�.0�e�r r r � <genexpr>3 s � z"session_via_cli.<locals>.<genexpr>) r r � build_parser� parse_args�tupler � verbosity�app_data� _interpreter) r r r r �parser�elements�creator�seeder� activatorsr r r r % s �r c C s� t ||d u r tjn|�}t|� |jdddddd� t|| |� t| ||�}t|� t|| �}|j |_ }|d u rBd|� �}t |��t ||�t ||�t||�g}|�| �\}} |D ]} | �|� qY|�� ||fS )Nz--with-traceback�with_traceback� store_trueFz>on failure also display the stacktrace internals of virtualenv)�dest�action�default�helpz failed to find interpreter for )r r r �add_version_flag� add_argument�_do_report_setup� load_app_data�handle_extra_commandsr � interpreterr' � RuntimeErrorr r r �parse_known_args�handle_selected_arg_parse� enable_help) r r r r r( �discoverr8 �msgr) �_�elementr r r r" > s4 � � r" c C s t | �d S )z0Used to provide a parser for the doc generation.r )r" )r r r r �build_parser_only] s rA c C s | j rt| j| j�}t|��d S r )�upgrade_embed_wheelsr r& r � SystemExit)r �resultr r r r7 b s �r7 c C s� |j dddd� |j| |d�\}}|j ddtt|j|jd�td |j|jd�d � |j d dd d� |j d dd d� |j| |d�\}}|jrI|j�� |S )Nz--read-only-app-datar. zMuse app data folder in read-only mode (write operations will fail with error))r0 r2 )� namespacez --app-dataz-a data folder used as cache by the virtualenv)� read_onlyr )r2 �typer1 z--reset-app-dataz start with empty app data folderz--upgrade-embed-wheelsz.trigger a manual update of the embedded wheels) r4 r: r r �read_only_app_datar �reset_app_datar& �reset)r r( r r? r r r r6 h s4 ���� r6 c C s, dd l }| jdddt� d|j� �dd� d S )Nr z --version�versionz %(prog)s z from zIdisplay the version of the virtualenv package and its location, then exit)r0 rK r2 )� virtualenvr4 r �__file__)r( rL r r r r3 � s �r3 c C s� d� dd� tt�� �D ��}d}| jd|�t�td �|�d�}|�� }|j dd d d d d d� |j ddd dddd� | � |�\}}|rJt |j � d S d S )Nz, c s s( � | ]\}}t �|�� d |� �V qdS )�=N)�logging� getLevelName)r �c�liner r r r! � s �& z#_do_report_setup.<locals>.<genexpr>z6verbosity = verbose - quiet, default {}, mapping => {}r% � )�title� descriptionz-vz --verbose�count�verbosezincrease verbosity� )r0 r/ r2 r1 z-qz--quiet�quietzdecrease verbosityr ) �join�sortedr �items�add_argument_group�formatrO rP � add_mutually_exclusive_groupr4 r: r r% ) r( r r � level_mapr> �verbosity_groupr% �optionr? r r r r5 � s ��r5 )NTN)NNTNr )$� __future__r rO r � functoolsr �virtualenv.app_datar � virtualenv.config.cli.parserr �virtualenv.reportr r �virtualenv.run.sessionr �&virtualenv.seed.wheels.periodic_updater �virtualenv.versionr �plugin.activatorsr �plugin.creatorsr �plugin.discoveryr �plugin.seedersr r r r" rA r7 r6 r3 r5 �__all__r r r r �<module> s2 � __pycache__/session.cpython-310.pyc 0000644 00000007226 15030371134 0013144 0 ustar 00 o }h� � @ sP d dl mZ d dlZd dlZe�e�ZG dd� d�ZdZG dd� d�Z dgZ dS )� )� annotationsNc @ s� e Zd ZdZd dd�Zedd� �Zedd � �Zed d � �Zed d � �Z edd� �Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) �Sessionz2Represents a virtual environment creation session.�return�Nonec C s( || _ || _|| _|| _|| _|| _d S �N)� _verbosity� _app_data� _interpreter�_creator�_seeder� _activators)�self� verbosity�app_data� interpreter�creator�seeder� activators� r �A/usr/local/lib/python3.10/dist-packages/virtualenv/run/session.py�__init__ s zSession.__init__c C � | j S )zThe verbosity of the run.)r �r r r r r � zSession.verbosityc C r )zACreate a virtual environment based on this reference interpreter.)r r r r r r r zSession.interpreterc C r )z\The creator used to build the virtual environment (must be compatible with the interpreter).)r r r r r r r zSession.creatorc C r )zIThe mechanism used to provide the seed packages (pip, setuptools, wheel).)r r r r r r # r zSession.seederc C r )z0Activators used to generate activations scripts.)r r r r r r ( r zSession.activatorsc C s( | � � | �� | �� | jj�� d S r )�_create�_seed� _activater � pyenv_cfg�writer r r r �run- s z Session.runc C s8 t �d| j� | j�� t �t� t �dt| j�� d S )Nz!create virtual environment via %sz%s)�LOGGER�infor r �debug� _DEBUG_MARKER�_Debugr r r r r 3 s zSession._createc C s: | j d ur| j jrt�d| j � | j �| j� d S d S d S )Nzadd seed packages via %s)r �enabledr r! r r r r r r r 9 s �z Session._seedc C sH | j r d�dd� | j D ��}t�d|� | j D ] }|�| j� qd S d S )Nz, c s s" � | ] }t |�j�d d�V qdS )� Activator� N)�type�__name__�replace)�.0�ir r r � <genexpr>@ s � z$Session._activate.<locals>.<genexpr>zadd activators for %s)r �joinr r! �generater )r �active� activatorr r r r > s �zSession._activatec C s | S r r r r r r � __enter__E s zSession.__enter__c C s | j �� d S r )r �close)r �exc_type�exc_val�exc_tbr r r �__exit__H s zSession.__exit__N�r r )r) � __module__� __qualname__�__doc__r �propertyr r r r r r r r r r2 r7 r r r r r s& r zJ============================== target debug ==============================c @ s$ e Zd ZdZd dd�Zd dd�Zd S ) r$ zlazily populate debug.r r c C s || _ d S r )r )r r r r r r R s z_Debug.__init__�strc C s t j| jjdd�S )N� )�indent)�json�dumpsr r" r r r r �__repr__U s z_Debug.__repr__Nr8 )r r= )r) r9 r: r; r rB r r r r r$ O s r$ ) � __future__r r@ �logging� getLoggerr) r r r# r$ �__all__r r r r �<module> s C � session.py 0000644 00000004667 15030371134 0006613 0 ustar 00 from __future__ import annotations import json import logging LOGGER = logging.getLogger(__name__) class Session: """Represents a virtual environment creation session.""" def __init__(self, verbosity, app_data, interpreter, creator, seeder, activators) -> None: # noqa: PLR0913 self._verbosity = verbosity self._app_data = app_data self._interpreter = interpreter self._creator = creator self._seeder = seeder self._activators = activators @property def verbosity(self): """The verbosity of the run.""" return self._verbosity @property def interpreter(self): """Create a virtual environment based on this reference interpreter.""" return self._interpreter @property def creator(self): """The creator used to build the virtual environment (must be compatible with the interpreter).""" return self._creator @property def seeder(self): """The mechanism used to provide the seed packages (pip, setuptools, wheel).""" return self._seeder @property def activators(self): """Activators used to generate activations scripts.""" return self._activators def run(self): self._create() self._seed() self._activate() self.creator.pyenv_cfg.write() def _create(self): LOGGER.info("create virtual environment via %s", self.creator) self.creator.run() LOGGER.debug(_DEBUG_MARKER) LOGGER.debug("%s", _Debug(self.creator)) def _seed(self): if self.seeder is not None and self.seeder.enabled: LOGGER.info("add seed packages via %s", self.seeder) self.seeder.run(self.creator) def _activate(self): if self.activators: active = ", ".join(type(i).__name__.replace("Activator", "") for i in self.activators) LOGGER.info("add activators for %s", active) for activator in self.activators: activator.generate(self.creator) def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self._app_data.close() _DEBUG_MARKER = "=" * 30 + " target debug " + "=" * 30 class _Debug: """lazily populate debug.""" def __init__(self, creator) -> None: self.creator = creator def __repr__(self) -> str: return json.dumps(self.creator.debug, indent=2) __all__ = [ "Session", ] plugin/base.py 0000644 00000004060 15030371134 0007323 0 ustar 00 from __future__ import annotations import sys from collections import OrderedDict from importlib.metadata import entry_points importlib_metadata_version = () class PluginLoader: _OPTIONS = None _ENTRY_POINTS = None @classmethod def entry_points_for(cls, key): if sys.version_info >= (3, 10) or importlib_metadata_version >= (3, 6): return OrderedDict((e.name, e.load()) for e in cls.entry_points().select(group=key)) return OrderedDict((e.name, e.load()) for e in cls.entry_points().get(key, {})) @staticmethod def entry_points(): if PluginLoader._ENTRY_POINTS is None: PluginLoader._ENTRY_POINTS = entry_points() return PluginLoader._ENTRY_POINTS class ComponentBuilder(PluginLoader): def __init__(self, interpreter, parser, name, possible) -> None: self.interpreter = interpreter self.name = name self._impl_class = None self.possible = possible self.parser = parser.add_argument_group(title=name) self.add_selector_arg_parse(name, list(self.possible)) @classmethod def options(cls, key): if cls._OPTIONS is None: cls._OPTIONS = cls.entry_points_for(key) return cls._OPTIONS def add_selector_arg_parse(self, name, choices): raise NotImplementedError def handle_selected_arg_parse(self, options): selected = getattr(options, self.name) if selected not in self.possible: msg = f"No implementation for {self.interpreter}" raise RuntimeError(msg) self._impl_class = self.possible[selected] self.populate_selected_argparse(selected, options.app_data) return selected def populate_selected_argparse(self, selected, app_data): self.parser.description = f"options for {self.name} {selected}" self._impl_class.add_parser_arguments(self.parser, self.interpreter, app_data) def create(self, options): return self._impl_class(options, self.interpreter) __all__ = [ "ComponentBuilder", "PluginLoader", ] plugin/__pycache__/activators.cpython-310.pyc 0000644 00000006230 15030371134 0015130 0 ustar 00 o }h� � @ sJ d dl mZ d dlmZ d dlmZ ddlmZ G dd� de�ZdgZ dS ) � )� annotations)�ArgumentTypeError)� OrderedDict� )�ComponentBuilderc s> e Zd Zd � fdd� Zdd� Zdd� Zd d � Zd d � Z� ZS )�ActivationSelector�return�Nonec sJ d | _ t� fdd�| �d��� D ��}t� �� |d|� d| j_d | _d S )Nc 3 s& � | ]\}}|� � �r||fV qd S )N)�supports��.0�k�v�� interpreter� �K/usr/local/lib/python3.10/dist-packages/virtualenv/run/plugin/activators.py� <genexpr> s � � �z.ActivationSelector.__init__.<locals>.<genexpr>zvirtualenv.activate� activatorsz options for activation scripts) �defaultr �options�items�super�__init__�parser� description�active)�selfr r �possible�� __class__r r r s � zActivationSelector.__init__c C s2 d� |�| _| jjd|� �| jddd| jd� d S )N�,z--�comma_sep_listFz1activators to generate - default is all supported)r �metavar�required�help�type)�joinr r � add_argument�_extract_activators)r �name�choicesr r r �add_selector_arg_parse s �z)ActivationSelector.add_selector_arg_parsec sF dd� |� d�D �}� fdd�|D �}|r!dd�|�� �}t|��|S )Nc S s g | ] }|� � r|� � �qS r )�strip�r �er r r � <listcomp> s z:ActivationSelector._extract_activators.<locals>.<listcomp>r! c s g | ] }|� j vr|�qS r )r r. �r r r r0 s z+the following activators are not available )�splitr' r )r � entered_str�elements�missing�msgr r1 r r) s z&ActivationSelector._extract_activatorsc sr |j | ju r | �| j�n|j � � fdd�| j�� D �| _| jjddddd d� | j�� D ] }|� | j| j � q,d S )Nc s i | ] \}}|� v r||�qS r r r ��selected_activatorsr r � <dictcomp>* s z@ActivationSelector.handle_selected_arg_parse.<locals>.<dictcomp>z--prompt�promptzsprovides an alternative prompt prefix for this environment (value of . means name of the current working directory))�destr# r% r ) r r r) r r r r r( �values�add_parser_argumentsr )r r � activatorr r7 r �handle_selected_arg_parse& s �� �z,ActivationSelector.handle_selected_arg_parsec s � fdd�| j �� D �S )Nc s g | ]}|� ��qS r r )r �activator_class�r r r r0 9 s z-ActivationSelector.create.<locals>.<listcomp>)r r< )r r r rA r �create8 s zActivationSelector.create)r r ) �__name__� __module__� __qualname__r r, r) r? rB � __classcell__r r r r r s r N) � __future__r �argparser � collectionsr �baser r �__all__r r r r �<module> s 4� plugin/__pycache__/__init__.cpython-310.pyc 0000644 00000000246 15030371134 0014511 0 ustar 00 o }h � @ s d S )N� r r r �I/usr/local/lib/python3.10/dist-packages/virtualenv/run/plugin/__init__.py�<module> s plugin/__pycache__/creators.cpython-310.pyc 0000644 00000007542 15030371134 0014602 0 ustar 00 o }h* � @ s� d dl mZ d dlmZmZ d dlmZmZ d dlm Z d dl m Z ddl m Z er2d dlmZmZ G d d � d e�ZG d d � d e �Zd d gZd S )� )� annotations)� OrderedDict� defaultdict)� TYPE_CHECKING� NamedTuple)�Describe)�VirtualenvBuiltin� )�ComponentBuilder)�Creator� CreatorMetac @ s. e Zd ZU ded< ded< ded< ded< d S ) � CreatorInfozdict[str, type[Creator]]� key_to_classzdict[str, CreatorMeta]� key_to_metaztype[Describe] | None�describe�str� builtin_keyN)�__name__� __module__� __qualname__�__annotations__� r r �I/usr/local/lib/python3.10/dist-packages/virtualenv/run/plugin/creators.pyr s r c sR e Zd Zd� fdd� Zedd� �Zdd� Zed d � �Zd d � Z � fd d�Z � Z S )�CreatorSelector�return�Nonec s. | � |�\}| _| _| _t� �||d|� d S )N�creator)�for_interpreterr r r �super�__init__)�self� interpreter�parser�creators�� __class__r r r s zCreatorSelector.__init__c C s t � i d d f\}}}}tt�}| �d��� D ]L\}}|dkr$d} t| ��|�|�} | rR| jr7|| j �|� nd|vrJt |t �rJ|}||d< | |d< |||< | ||< |d u rbt |t �rb|� |�rb|}q|s�|rwdd� |�� D �} td� | ���d|� �} t| ��t||||d�S ) Nzvirtualenv.create�builtinz"builtin creator is a reserved namec S s. g | ]\}}|� d d� dd� |D ��� ��qS )z for creators z, c s s � | ]}|j V qd S �N)r )�.0�ir r r � <genexpr>2 s � z=CreatorSelector.for_interpreter.<locals>.<listcomp>.<genexpr>)�join)r( �k�vr r r � <listcomp>2 s . z3CreatorSelector.for_interpreter.<locals>.<listcomp>� z!No virtualenv implementation for )r r r r )r r �list�options�items� RuntimeError� can_create�error�append� issubclassr r � can_describer+ r ) �clsr! r r r r �errors�key� creator_class�msg�meta�rowsr r r r s> � �z CreatorSelector.for_interpreterc C sX t |dd� d�}| �|�}| jjd|� �||dd| jd u r dnd| j� d �� �d � d S ) Nc S s | dkrdS dS )Nr& r r r )�ar r r �<lambda>? s z8CreatorSelector.add_selector_arg_parse.<locals>.<lambda>)r; z--Fzcreate environment via� z (builtin = �))�choices�default�required�help)�sorted� _get_defaultr" � add_argumentr )r �namerD � default_valuer r r �add_selector_arg_parse= s �z&CreatorSelector.add_selector_arg_parsec C s t t| ��S r' )�next�iter)rD r r r rI I s z CreatorSelector._get_defaultc C s6 d| j � d|� �| j_| j�| j| j| j| |� d S )Nz options for � )rK r" � description� _impl_class�add_parser_argumentsr! r )r �selected�app_datar r r �populate_selected_argparseM s z*CreatorSelector.populate_selected_argparsec s< | j t|| j� |_t| jt�s| �|| j�|_t � � |�S r' ) r �getattrrK r> r7 rR r r r! r �create)r r1 r$ r r rX Q s zCreatorSelector.create)r r ) r r r r � classmethodr rM � staticmethodrI rV rX � __classcell__r r r$ r r s ! r N)� __future__r � collectionsr r �typingr r �virtualenv.create.describer �4virtualenv.create.via_global_ref.builtin.builtin_wayr �baser �virtualenv.create.creatorr r r r �__all__r r r r �<module> s C� plugin/__pycache__/seeders.cpython-310.pyc 0000644 00000003156 15030371134 0014407 0 ustar 00 o }h � @ s2 d dl mZ ddlmZ G dd� de�ZdgZdS )� )� annotations� )�ComponentBuilderc sF e Zd Zd � fdd� Zdd� Zedd� �Z� fd d �Zd d � Z� Z S )�SeederSelector�return�Nonec s | � d�}t� �||d|� d S )Nzvirtualenv.seed�seeder)�options�super�__init__)�self� interpreter�parser�possible�� __class__� �H/usr/local/lib/python3.10/dist-packages/virtualenv/run/plugin/seeders.pyr s zSeederSelector.__init__c C s: | j jd|� �|| �� ddd� | j jddddd d � d S ) Nz--Fz seed packages install method)�choices�default�required�helpz --no-seedz --without-pipz do not install seed packages� store_true�no_seed)r �action�dest)r � add_argument� _get_default)r �namer r r r �add_selector_arg_parse s � �z%SeederSelector.add_selector_arg_parsec C s dS )Nzapp-datar r r r r r s zSeederSelector._get_defaultc s t � �|�S �N)r �handle_selected_arg_parse�r r r r r r! s z(SeederSelector.handle_selected_arg_parsec C s | � |�S r )� _impl_classr" r r r �create" s zSeederSelector.create)r r ) �__name__� __module__� __qualname__r r � staticmethodr r! r$ � __classcell__r r r r r s r N)� __future__r �baser r �__all__r r r r �<module> s !� plugin/__pycache__/discovery.cpython-310.pyc 0000644 00000002630 15030371134 0014760 0 ustar 00 o }h� � @ sD d dl mZ ddlmZ G dd� de�Zdd� Zdd � ZddgZd S ) � )� annotations� )� PluginLoaderc @ s e Zd ZdZdS )� DiscoveryzDiscovery plugins.N)�__name__� __module__� __qualname__�__doc__� r r �J/usr/local/lib/python3.10/dist-packages/virtualenv/run/plugin/discovery.pyr s r c C s� t �d�}| jddd�}t|�}t|dd� d�}|jd|tt|��d d d � | �|�\}}||j }|� |� | j||d �\}}||�S ) Nzvirtualenv.discovery� discoveryz)discover and provide a target interpreter)�title� descriptionc S s | dkrdS dS )N�builtinr r r )�ar r r �<lambda> s z get_discover.<locals>.<lambda>)�keyz --discoveryFz interpreter discovery method)�choices�default�required�help)� namespace) r �entry_points_for�add_argument_group�_get_default_discovery�sorted� add_argument�next�iter�parse_known_argsr �add_parser_arguments)�parser�args�discover_types�discovery_parserr �options�_�discover_classr r r � get_discover s& � � r( c C s t | �� �S )N)�list�keys)r# r r r r ! s r N)� __future__r �baser r r( r �__all__r r r r �<module> s � plugin/__pycache__/base.cpython-310.pyc 0000644 00000005565 15030371134 0013675 0 ustar 00 o }h0 � @ sZ d dl mZ d dlZd dlmZ d dlmZ dZG dd� d�ZG dd � d e�Z d dgZ dS ) � )� annotationsN)� OrderedDict)� entry_points� c @ s, e Zd ZdZdZedd� �Zedd� �ZdS )� PluginLoaderNc C sN t jdks tdkrtdd� | �� j|d�D ��S tdd� | �� �|i �D ��S )N)� � )r � c s � � | ] }|j |�� fV qd S �N��name�load��.0�er r �E/usr/local/lib/python3.10/dist-packages/virtualenv/run/plugin/base.py� <genexpr> � � z0PluginLoader.entry_points_for.<locals>.<genexpr>)�groupc s r r r r r r r r r )�sys� version_info�importlib_metadata_versionr r �select�get��cls�keyr r r �entry_points_for s z PluginLoader.entry_points_forc C s t jd u r t� t _t jS r )r � _ENTRY_POINTSr r r r r r s zPluginLoader.entry_points) �__name__� __module__� __qualname__�_OPTIONSr � classmethodr � staticmethodr r r r r r s r c @ sB e Zd Zddd�Zedd� �Zdd� Zd d � Zd d � Zd d� Z dS )�ComponentBuilder�return�Nonec C s< || _ || _d | _|| _|j|d�| _| �|t| j�� d S )N)�title)� interpreterr � _impl_class�possible�add_argument_group�parser�add_selector_arg_parse�list)�selfr* r. r r, r r r �__init__ s zComponentBuilder.__init__c C s | j d u r | �|�| _ | j S r )r# r r r r r �options$ s zComponentBuilder.optionsc C s t �r )�NotImplementedError)r1 r �choicesr r r r/ * s z'ComponentBuilder.add_selector_arg_parsec C sH t || j�}|| jvrd| j� �}t|��| j| | _| �||j� |S )NzNo implementation for )�getattrr r, r* � RuntimeErrorr+ �populate_selected_argparse�app_data)r1 r3 �selected�msgr r r �handle_selected_arg_parse- s z*ComponentBuilder.handle_selected_arg_parsec C s. d| j � d|� �| j_| j�| j| j|� d S )Nz options for � )r r. � descriptionr+ �add_parser_argumentsr* )r1 r: r9 r r r r8 6 s z+ComponentBuilder.populate_selected_argparsec C s | � || j�S r )r+ r* )r1 r3 r r r �create: s zComponentBuilder.createN)r' r( ) r r! r" r2 r$ r3 r/ r< r8 r@ r r r r r& s r& ) � __future__r r � collectionsr �importlib.metadatar r r r& �__all__r r r r �<module> s $� plugin/seeders.py 0000644 00000002032 15030371134 0010040 0 ustar 00 from __future__ import annotations from .base import ComponentBuilder class SeederSelector(ComponentBuilder): def __init__(self, interpreter, parser) -> None: possible = self.options("virtualenv.seed") super().__init__(interpreter, parser, "seeder", possible) def add_selector_arg_parse(self, name, choices): self.parser.add_argument( f"--{name}", choices=choices, default=self._get_default(), required=False, help="seed packages install method", ) self.parser.add_argument( "--no-seed", "--without-pip", help="do not install seed packages", action="store_true", dest="no_seed", ) @staticmethod def _get_default(): return "app-data" def handle_selected_arg_parse(self, options): return super().handle_selected_arg_parse(options) def create(self, options): return self._impl_class(options) __all__ = [ "SeederSelector", ] plugin/activators.py 0000644 00000004273 15030371134 0010576 0 ustar 00 from __future__ import annotations from argparse import ArgumentTypeError from collections import OrderedDict from .base import ComponentBuilder class ActivationSelector(ComponentBuilder): def __init__(self, interpreter, parser) -> None: self.default = None possible = OrderedDict( (k, v) for k, v in self.options("virtualenv.activate").items() if v.supports(interpreter) ) super().__init__(interpreter, parser, "activators", possible) self.parser.description = "options for activation scripts" self.active = None def add_selector_arg_parse(self, name, choices): self.default = ",".join(choices) self.parser.add_argument( f"--{name}", default=self.default, metavar="comma_sep_list", required=False, help="activators to generate - default is all supported", type=self._extract_activators, ) def _extract_activators(self, entered_str): elements = [e.strip() for e in entered_str.split(",") if e.strip()] missing = [e for e in elements if e not in self.possible] if missing: msg = f"the following activators are not available {','.join(missing)}" raise ArgumentTypeError(msg) return elements def handle_selected_arg_parse(self, options): selected_activators = ( self._extract_activators(self.default) if options.activators is self.default else options.activators ) self.active = {k: v for k, v in self.possible.items() if k in selected_activators} self.parser.add_argument( "--prompt", dest="prompt", metavar="prompt", help=( "provides an alternative prompt prefix for this environment " "(value of . means name of the current working directory)" ), default=None, ) for activator in self.active.values(): activator.add_parser_arguments(self.parser, self.interpreter) def create(self, options): return [activator_class(options) for activator_class in self.active.values()] __all__ = [ "ActivationSelector", ] plugin/discovery.py 0000644 00000002234 15030371134 0010421 0 ustar 00 from __future__ import annotations from .base import PluginLoader class Discovery(PluginLoader): """Discovery plugins.""" def get_discover(parser, args): discover_types = Discovery.entry_points_for("virtualenv.discovery") discovery_parser = parser.add_argument_group( title="discovery", description="discover and provide a target interpreter", ) choices = _get_default_discovery(discover_types) # prefer the builtin if present, otherwise fallback to first defined type choices = sorted(choices, key=lambda a: 0 if a == "builtin" else 1) discovery_parser.add_argument( "--discovery", choices=choices, default=next(iter(choices)), required=False, help="interpreter discovery method", ) options, _ = parser.parse_known_args(args) discover_class = discover_types[options.discovery] discover_class.add_parser_arguments(discovery_parser) options, _ = parser.parse_known_args(args, namespace=options) return discover_class(options) def _get_default_discovery(discover_types): return list(discover_types.keys()) __all__ = [ "Discovery", "get_discover", ] plugin/__init__.py 0000644 00000000000 15030371134 0010136 0 ustar 00 plugin/creators.py 0000644 00000007052 15030371134 0010237 0 ustar 00 from __future__ import annotations from collections import OrderedDict, defaultdict from typing import TYPE_CHECKING, NamedTuple from virtualenv.create.describe import Describe from virtualenv.create.via_global_ref.builtin.builtin_way import VirtualenvBuiltin from .base import ComponentBuilder if TYPE_CHECKING: from virtualenv.create.creator import Creator, CreatorMeta class CreatorInfo(NamedTuple): key_to_class: dict[str, type[Creator]] key_to_meta: dict[str, CreatorMeta] describe: type[Describe] | None builtin_key: str class CreatorSelector(ComponentBuilder): def __init__(self, interpreter, parser) -> None: creators, self.key_to_meta, self.describe, self.builtin_key = self.for_interpreter(interpreter) super().__init__(interpreter, parser, "creator", creators) @classmethod def for_interpreter(cls, interpreter): key_to_class, key_to_meta, builtin_key, describe = OrderedDict(), {}, None, None errors = defaultdict(list) for key, creator_class in cls.options("virtualenv.create").items(): if key == "builtin": msg = "builtin creator is a reserved name" raise RuntimeError(msg) meta = creator_class.can_create(interpreter) if meta: if meta.error: errors[meta.error].append(creator_class) else: if "builtin" not in key_to_class and issubclass(creator_class, VirtualenvBuiltin): builtin_key = key key_to_class["builtin"] = creator_class key_to_meta["builtin"] = meta key_to_class[key] = creator_class key_to_meta[key] = meta if describe is None and issubclass(creator_class, Describe) and creator_class.can_describe(interpreter): describe = creator_class if not key_to_meta: if errors: rows = [f"{k} for creators {', '.join(i.__name__ for i in v)}" for k, v in errors.items()] raise RuntimeError("\n".join(rows)) msg = f"No virtualenv implementation for {interpreter}" raise RuntimeError(msg) return CreatorInfo( key_to_class=key_to_class, key_to_meta=key_to_meta, describe=describe, builtin_key=builtin_key, ) def add_selector_arg_parse(self, name, choices): # prefer the built-in venv if present, otherwise fallback to first defined type choices = sorted(choices, key=lambda a: 0 if a == "builtin" else 1) default_value = self._get_default(choices) self.parser.add_argument( f"--{name}", choices=choices, default=default_value, required=False, help=f"create environment via{'' if self.builtin_key is None else f' (builtin = {self.builtin_key})'}", ) @staticmethod def _get_default(choices): return next(iter(choices)) def populate_selected_argparse(self, selected, app_data): self.parser.description = f"options for {self.name} {selected}" self._impl_class.add_parser_arguments(self.parser, self.interpreter, self.key_to_meta[selected], app_data) def create(self, options): options.meta = self.key_to_meta[getattr(options, self.name)] if not issubclass(self._impl_class, Describe): options.describe = self.describe(options, self.interpreter) return super().create(options) __all__ = [ "CreatorInfo", "CreatorSelector", ] __init__.py 0000644 00000014144 15030371134 0006656 0 ustar 00 from __future__ import annotations import logging import os from functools import partial from virtualenv.app_data import make_app_data from virtualenv.config.cli.parser import VirtualEnvConfigParser from virtualenv.report import LEVELS, setup_report from virtualenv.run.session import Session from virtualenv.seed.wheels.periodic_update import manual_upgrade from virtualenv.version import __version__ from .plugin.activators import ActivationSelector from .plugin.creators import CreatorSelector from .plugin.discovery import get_discover from .plugin.seeders import SeederSelector def cli_run(args, options=None, setup_logging=True, env=None): # noqa: FBT002 """ Create a virtual environment given some command line interface arguments. :param args: the command line arguments :param options: passing in a ``VirtualEnvOptions`` object allows return of the parsed options :param setup_logging: ``True`` if setup logging handlers, ``False`` to use handlers already registered :param env: environment variables to use :return: the session object of the creation (its structure for now is experimental and might change on short notice) """ env = os.environ if env is None else env of_session = session_via_cli(args, options, setup_logging, env) with of_session: of_session.run() return of_session def session_via_cli(args, options=None, setup_logging=True, env=None): # noqa: FBT002 """ Create a virtualenv session (same as cli_run, but this does not perform the creation). Use this if you just want to query what the virtual environment would look like, but not actually create it. :param args: the command line arguments :param options: passing in a ``VirtualEnvOptions`` object allows return of the parsed options :param setup_logging: ``True`` if setup logging handlers, ``False`` to use handlers already registered :param env: environment variables to use :return: the session object of the creation (its structure for now is experimental and might change on short notice) """ # noqa: D205 env = os.environ if env is None else env parser, elements = build_parser(args, options, setup_logging, env) options = parser.parse_args(args) creator, seeder, activators = tuple(e.create(options) for e in elements) # create types return Session( options.verbosity, options.app_data, parser._interpreter, # noqa: SLF001 creator, seeder, activators, ) def build_parser(args=None, options=None, setup_logging=True, env=None): # noqa: FBT002 parser = VirtualEnvConfigParser(options, os.environ if env is None else env) add_version_flag(parser) parser.add_argument( "--with-traceback", dest="with_traceback", action="store_true", default=False, help="on failure also display the stacktrace internals of virtualenv", ) _do_report_setup(parser, args, setup_logging) options = load_app_data(args, parser, options) handle_extra_commands(options) discover = get_discover(parser, args) parser._interpreter = interpreter = discover.interpreter # noqa: SLF001 if interpreter is None: msg = f"failed to find interpreter for {discover}" raise RuntimeError(msg) elements = [ CreatorSelector(interpreter, parser), SeederSelector(interpreter, parser), ActivationSelector(interpreter, parser), ] options, _ = parser.parse_known_args(args) for element in elements: element.handle_selected_arg_parse(options) parser.enable_help() return parser, elements def build_parser_only(args=None): """Used to provide a parser for the doc generation.""" return build_parser(args)[0] def handle_extra_commands(options): if options.upgrade_embed_wheels: result = manual_upgrade(options.app_data, options.env) raise SystemExit(result) def load_app_data(args, parser, options): parser.add_argument( "--read-only-app-data", action="store_true", help="use app data folder in read-only mode (write operations will fail with error)", ) options, _ = parser.parse_known_args(args, namespace=options) # here we need a write-able application data (e.g. the zipapp might need this for discovery cache) parser.add_argument( "--app-data", help="a data folder used as cache by the virtualenv", type=partial(make_app_data, read_only=options.read_only_app_data, env=options.env), default=make_app_data(None, read_only=options.read_only_app_data, env=options.env), ) parser.add_argument( "--reset-app-data", action="store_true", help="start with empty app data folder", ) parser.add_argument( "--upgrade-embed-wheels", action="store_true", help="trigger a manual update of the embedded wheels", ) options, _ = parser.parse_known_args(args, namespace=options) if options.reset_app_data: options.app_data.reset() return options def add_version_flag(parser): import virtualenv # noqa: PLC0415 parser.add_argument( "--version", action="version", version=f"%(prog)s {__version__} from {virtualenv.__file__}", help="display the version of the virtualenv package and its location, then exit", ) def _do_report_setup(parser, args, setup_logging): level_map = ", ".join(f"{logging.getLevelName(line)}={c}" for c, line in sorted(LEVELS.items())) msg = "verbosity = verbose - quiet, default {}, mapping => {}" verbosity_group = parser.add_argument_group( title="verbosity", description=msg.format(logging.getLevelName(LEVELS[3]), level_map), ) verbosity = verbosity_group.add_mutually_exclusive_group() verbosity.add_argument("-v", "--verbose", action="count", dest="verbose", help="increase verbosity", default=2) verbosity.add_argument("-q", "--quiet", action="count", dest="quiet", help="decrease verbosity", default=0) option, _ = parser.parse_known_args(args) if setup_logging: setup_report(option.verbosity) __all__ = [ "cli_run", "session_via_cli", ]
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings