tessl/pypi-poetry

Python dependency management and packaging made easy.

—

Pending

Overview

Eval results

Files

Configuration Management

Name: tessl/pypi-poetry
Author: tessl

Comprehensive configuration system for managing Poetry settings, package sources, and environment preferences. Handles both global and project-specific configuration options through a hierarchical configuration system.

Capabilities

Configuration System

Central configuration management providing access to Poetry settings, repository configurations, virtual environment preferences, and caching options.

class Config:
    """
    Poetry configuration management system.
    
    Handles global configuration, user preferences, and project-specific
    settings with support for configuration merging and validation.
    """
    
    @property
    def default_config(self) -> dict:
        """Default configuration values."""
    
    @property
    def repository_cache_directory(self) -> Path:
        """Cache directory for repository data."""
    
    @property
    def artifacts_cache_directory(self) -> Path:
        """Cache directory for package artifacts."""
    
    @property
    def virtualenvs_path(self) -> Path:
        """Base path for virtual environments."""
    
    @property
    def python_installation_dir(self) -> Path:
        """Directory for Python installations."""
    
    @property
    def installer_max_workers(self) -> int:
        """Maximum parallel workers for installation."""
    
    def get(self, setting_name: str, default = None):
        """
        Get configuration value by name.
        
        Args:
            setting_name: Configuration key (supports dot notation)
            default: Default value if not found
            
        Returns:
            Configuration value or default
        """
    
    def merge(self, config: dict) -> Config:
        """
        Merge configuration with existing settings.
        
        Args:
            config: Configuration dictionary to merge
            
        Returns:
            Self for method chaining
        """
    
    def all(self) -> dict:
        """
        Get all configuration as dictionary.
        
        Returns:
            Complete configuration dictionary
        """
    
    @staticmethod
    def create(reload: bool = False) -> Config:
        """
        Create default configuration instance.
        
        Args:
            reload: Whether to reload configuration from files
            
        Returns:
            Configured Config instance
        """

Usage Example

from poetry.config.config import Config

# Create configuration instance
config = Config.create()

# Get configuration values
cache_dir = config.get("cache-dir")
venv_path = config.get("virtualenvs.path")
parallel_workers = config.get("installer.max-workers", 4)

# Access properties
print(f"Artifacts cache: {config.artifacts_cache_directory}")
print(f"Virtual envs: {config.virtualenvs_path}")
print(f"Max workers: {config.installer_max_workers}")

# Merge custom configuration
config.merge({
    "virtualenvs.create": True,
    "virtualenvs.in-project": False,
    "repositories.custom": {
        "url": "https://my-repo.com/simple/"
    }
})

# Get all configuration
all_config = config.all()

Package Sources

Configuration and management of package repositories and sources with support for priorities and authentication.

class Source:
    """
    Package source configuration.
    
    Represents a package repository source with priority handling
    and conversion utilities for different configuration formats.
    """
    
    name: str      # Source name/identifier
    url: str       # Repository URL
    priority: str  # Source priority (default, primary, supplemental, explicit)
    
    def to_dict(self) -> dict:
        """
        Convert source to dictionary representation.
        
        Returns:
            Dictionary with source configuration
        """
    
    def to_toml_table(self) -> dict:
        """
        Convert source to TOML table format.
        
        Returns:
            Dictionary formatted for TOML serialization
        """

Usage Example

from poetry.config.source import Source

# Create package source
source = Source(
    name="private-repo",
    url="https://my-private-repo.com/simple/",
    priority="primary"
)

# Convert to different formats
source_dict = source.to_dict()
toml_data = source.to_toml_table()

# Use in pyproject.toml configuration
pyproject_sources = [
    {
        "name": "pypi",
        "url": "https://pypi.org/simple/",
        "priority": "default"
    },
    source.to_dict()
]

Configuration Keys

Standard configuration keys and their purposes:

# Cache configuration
CACHE_DIR = "cache-dir"                    # Base cache directory
ARTIFACTS_CACHE_DIR = "cache.artifacts"    # Package artifacts cache
REPOSITORY_CACHE_DIR = "cache.repositories" # Repository metadata cache

# Virtual environment configuration  
VIRTUALENVS_CREATE = "virtualenvs.create"     # Auto-create virtual environments
VIRTUALENVS_IN_PROJECT = "virtualenvs.in-project"  # Create .venv in project
VIRTUALENVS_PATH = "virtualenvs.path"         # Base path for virtual environments
VIRTUALENVS_PREFER_ACTIVE_PYTHON = "virtualenvs.prefer-active-python"

# Installation configuration
INSTALLER_MAX_WORKERS = "installer.max-workers"  # Parallel installation workers
INSTALLER_NO_BINARY = "installer.no-binary"      # Disable binary packages
INSTALLER_MODERN_INSTALLATION = "installer.modern-installation"

# Repository configuration
REPOSITORIES = "repositories"                # Custom repositories
PYPI_TOKEN = "pypi-token"                   # PyPI authentication token
HTTP_BASIC_AUTH = "http-basic"              # HTTP basic authentication

# Solver configuration
SOLVER_LAZY_WHEEL = "solver.lazy-wheel"     # Lazy wheel building

Configuration Usage Example

from poetry.config.config import Config

config = Config.create()

# Virtual environment settings
config.merge({
    "virtualenvs.create": True,
    "virtualenvs.in-project": False,
    "virtualenvs.path": "/custom/venv/path",
    "virtualenvs.prefer-active-python": True
})

# Installation settings
config.merge({
    "installer.max-workers": 8,
    "installer.modern-installation": True
})

# Repository authentication
config.merge({
    "http-basic.private-repo.username": "user",
    "http-basic.private-repo.password": "pass",
    "repositories.private-repo.url": "https://private-repo.com/simple/"
})

# Cache settings
config.merge({
    "cache-dir": "/custom/cache/dir",
    "solver.lazy-wheel": True
})

Configuration File Locations

Poetry reads configuration from multiple locations in order of precedence:

def get_config_locations() -> list[Path]:
    """
    Get configuration file locations in order of precedence.
    
    Returns:
        List of configuration file paths
    """

def get_user_config_dir() -> Path:
    """
    Get user-specific configuration directory.
    
    Returns:
        Path to user configuration directory
    """

def get_system_config_dir() -> Path:
    """
    Get system-wide configuration directory.
    
    Returns:
        Path to system configuration directory
    """

Configuration precedence (highest to lowest):

Environment variables (POETRY_*)
Command-line options
Project-local configuration (.poetry/config.toml)
User configuration (~/.config/pypoetry/config.toml)
System configuration
Default values

Environment Variable Configuration

Poetry configuration can be overridden using environment variables:

# Virtual environment settings
POETRY_VIRTUALENVS_CREATE=false
POETRY_VIRTUALENVS_IN_PROJECT=true
POETRY_VIRTUALENVS_PATH=/custom/path

# Cache settings
POETRY_CACHE_DIR=/custom/cache
POETRY_NO_INTERACTION=1

# Repository settings
POETRY_REPOSITORIES_CUSTOM_URL=https://repo.example.com/simple/
POETRY_HTTP_BASIC_CUSTOM_USERNAME=user
POETRY_HTTP_BASIC_CUSTOM_PASSWORD=pass

# Installation settings
POETRY_INSTALLER_MAX_WORKERS=4
POETRY_INSTALLER_MODERN_INSTALLATION=true

Advanced Configuration Patterns

Custom Repository Configuration

from poetry.config.config import Config
from poetry.config.source import Source

config = Config.create()

# Add custom repository with authentication
config.merge({
    "repositories.company-internal": {
        "url": "https://internal-repo.company.com/simple/"
    },
    "http-basic.company-internal.username": "employee",
    "http-basic.company-internal.password": "secure-token"
})

# Create source for pyproject.toml
internal_source = Source(
    name="company-internal",
    url="https://internal-repo.company.com/simple/",
    priority="supplemental"
)

Development Environment Setup

from poetry.config.config import Config

def setup_dev_config():
    """Configure Poetry for development environment."""
    config = Config.create()
    
    # Development-friendly settings
    config.merge({
        "virtualenvs.in-project": True,      # .venv in project
        "virtualenvs.prefer-active-python": True,  # Use active Python
        "installer.max-workers": 1,          # Sequential for debugging
        "solver.lazy-wheel": False,          # Build wheels eagerly
        "cache-dir": "./dev-cache"           # Local cache
    })
    
    return config

Production Configuration

from poetry.config.config import Config

def setup_production_config():
    """Configure Poetry for production deployment."""
    config = Config.create()
    
    # Production-optimized settings
    config.merge({
        "virtualenvs.create": False,         # Use system Python
        "installer.max-workers": 4,          # Parallel installation
        "installer.modern-installation": True, # Modern resolver
        "cache-dir": "/opt/poetry/cache"     # System cache
    })
    
    return config

Error Handling

Configuration-related exceptions and error conditions:

class ConfigurationError(PoetryError):
    """Configuration-related errors."""

class InvalidConfigurationError(ConfigurationError):
    """Invalid configuration values or format."""

class ConfigurationFileError(ConfigurationError):
    """Configuration file reading/writing errors."""

Common configuration errors: