tessl/pypi-requirementslib

A tool for converting between pip-style and pipfile requirements.

—

Pending

Overview

Eval results

Files

Requirement Processing

Name: tessl/pypi-requirementslib
Author: tessl

The Requirement class is the core component for parsing, manipulating, and converting individual package requirements. It provides comprehensive support for all types of Python package requirements including named packages, VCS requirements, file/URL requirements, editable installs, environment markers, and package hashes.

Capabilities

Requirement Creation

Create Requirement objects from various sources including requirements.txt lines, Pipfile entries, pip InstallRequirement objects, and package metadata.

class Requirement:
    def __init__(self, **kwargs):
        """
        Initialize requirement from various parameters.
        
        Parameters:
        - name: Package name
        - vcs: VCS type (git, hg, svn, bzr)
        - req: Internal requirement object
        - markers: Environment markers string
        - index: Package index name
        - editable: Whether package is editable install
        - hashes: Set of package hashes
        - extras: Package extras tuple
        """

    @classmethod
    def from_line(cls, line, parse_setup_info=True):
        """
        Parse requirement from requirements.txt line.
        
        Parameters:
        - line: Requirements.txt line string
        - parse_setup_info: Whether to parse setup.py information
        
        Returns:
        Requirement object
        """

    @classmethod
    def from_ireq(cls, ireq):
        """
        Create from pip InstallRequirement object.
        
        Parameters:
        - ireq: pip InstallRequirement instance
        
        Returns:
        Requirement object
        """

    @classmethod  
    def from_metadata(cls, name, version, extras, markers):
        """
        Create from metadata components.
        
        Parameters:
        - name: Package name
        - version: Version string
        - extras: Package extras
        - markers: Environment markers
        
        Returns:
        Requirement object
        """

    @classmethod
    def from_pipfile(cls, name, pipfile):
        """
        Create from Pipfile entry.
        
        Parameters:
        - name: Package name
        - pipfile: Pipfile entry data
        
        Returns:
        Requirement object
        """

Core Fields

Pydantic fields that store requirement metadata and configuration.

class Requirement:
    name: Optional[str]
        """Package name"""
    
    vcs: Optional[str] 
        """VCS type if VCS requirement"""
    
    req: Optional[Any]
        """Internal requirement object"""
    
    markers: Optional[str]
        """Environment markers string"""
    
    index: Optional[str]
        """Package index name"""
    
    editable: Optional[bool]
        """Whether package is editable install"""
    
    hashes: Set[str]
        """Set of package hashes"""
    
    extras: Tuple[str, ...]
        """Package extras tuple"""

Computed Properties

Cached properties that compute derived information from the requirement fields.

class Requirement:
    @property
    def requirement(self):
        """Packaging requirement object"""
    
    @property
    def normalized_name(self) -> str:
        """Canonicalized package name"""
    
    @property
    def specifiers(self):
        """Version specifiers string"""
    
    @property
    def extras_as_pip(self) -> str:
        """Formatted extras string for pip"""
    
    @property
    def get_specifiers(self) -> str:
        """Version specifiers string"""
    
    @property
    def get_markers(self):
        """Parsed environment markers"""
    
    @property
    def get_specifier(self):
        """Parsed specifier object"""
    
    @property
    def get_version(self):
        """Parsed version object"""
    
    @property
    def line_instance(self):
        """Line instance for this requirement"""
    
    @property  
    def ireq(self):
        """InstallRequirement object"""
    
    @property
    def is_vcs(self) -> bool:
        """Whether this is a VCS requirement"""
    
    @property
    def is_file_or_url(self) -> bool:
        """Whether this is file/URL requirement"""
    
    @property
    def is_named(self) -> bool:
        """Whether this is a named requirement"""
    
    @property
    def is_wheel(self) -> bool:
        """Whether this is a wheel file"""
    
    @property
    def is_direct_url(self) -> bool:
        """Whether this uses direct URL format"""
    
    @property
    def hashes_as_pip(self) -> str:
        """Formatted hashes string for pip"""
    
    @property
    def commit_hash(self) -> Optional[str]:
        """VCS commit hash if applicable"""
    
    @property
    def constraint_line(self) -> str:
        """Formatted constraint line"""
    
    @property
    def pipfile_entry(self) -> Tuple[str, Any]:
        """Pipfile format entry"""

Format Conversion

Convert requirements between different formats while preserving all metadata.

class Requirement:
    def as_line(self, sources=None, include_hashes=True, include_extras=True, include_markers=True, as_list=False):
        """
        Format as requirements.txt line.
        
        Parameters:
        - sources: Package sources for index URLs
        - include_hashes: Whether to include package hashes
        - include_extras: Whether to include package extras
        - include_markers: Whether to include environment markers
        - as_list: Return as list instead of string
        
        Returns:
        Requirements.txt formatted string or list
        """

    def as_pipfile(self):
        """
        Format as Pipfile entry.
        
        Returns:
        Dict containing Pipfile entry data
        """

    def as_ireq(self):
        """
        Convert to pip InstallRequirement.
        
        Returns:
        pip InstallRequirement object
        """

    def get_requirement(self):
        """
        Get packaging requirement object.
        
        Returns:
        packaging.requirements.Requirement object
        """

Hash Management

Add and format package hashes for integrity verification.

class Requirement:
    def add_hashes(self, hashes: set):
        """
        Add hash values to requirement (modifies in place).
        
        Parameters:
        - hashes: Set of hash strings
        """

    def get_hashes_as_pip(self, as_list: bool = False):
        """
        Format hashes for pip.
        
        Parameters:
        - as_list: Return as list instead of string
        
        Returns:
        Formatted hashes string or list
        """

Advanced Operations

Advanced functionality for working with requirement metadata and dependencies.

class Requirement:
    def update_name_from_path(self, path: str) -> None:
        """
        Update name from filesystem path.
        
        Parameters:
        - path: Filesystem path to package
        """

    def get_line_instance(self):
        """
        Get Line instance for this requirement.
        
        Returns:
        Line object
        """

    def get_version_from_setup_info(self):
        """
        Extract version from setup information.
        
        Returns:
        Tuple of (version_string, is_dynamic)
        """

    def run_requires(self, sources=None, finder=None):
        """
        Get requirement dependencies.
        
        Parameters:
        - sources: Package sources
        - finder: Package finder instance
        
        Returns:
        Dict containing dependency information
        """

    def merge_markers(self, markers):
        """
        Merge environment markers.
        
        Parameters:
        - markers: Additional markers to merge
        
        Returns:
        New Requirement object with merged markers
        """

Usage Examples

Basic Requirement Parsing

from requirementslib import Requirement

# Parse simple named requirement
req = Requirement.from_line("requests>=2.25.0")
print(req.name)           # "requests"
print(req.specifiers)     # ">=2.25.0"

# Parse requirement with extras and markers
req = Requirement.from_line("requests[security]>=2.25.0; python_version>='3.6'")
print(req.extras)         # ("security",)
print(req.markers)        # "python_version>='3.6'"

# Parse VCS requirement
req = Requirement.from_line("git+https://github.com/requests/requests.git@v2.25.0#egg=requests")
print(req.is_vcs)         # True
print(req.vcs)            # "git"
print(req.commit_hash)    # "v2.25.0"

# Parse editable requirement
req = Requirement.from_line("-e ./local-package")
print(req.editable)       # True

Format Conversion

from requirementslib import Requirement

# Create requirement and convert between formats
req = Requirement.from_line("requests[security]>=2.25.0")

# Convert to Pipfile format
pipfile_entry = req.as_pipfile()
# {"requests": {"version": ">=2.25.0", "extras": ["security"]}}

# Convert back to requirements.txt format
line = req.as_line()
# "requests[security]>=2.25.0"

# Convert to pip InstallRequirement
ireq = req.as_ireq()
print(type(ireq).__name__)  # "InstallRequirement"

Hash Management

from requirementslib import Requirement

# Create requirement and add hashes
req = Requirement.from_line("requests==2.25.0")
hashes = {
    "sha256:e786e8c8b9b5e9c8f1d6a9b8c7d6e5f4a3b2c1d0e9f8g7h6i5j4k3l2m1n0",
    "sha256:f9f8e7d6c5b4a3b2c1d0e9f8g7h6i5j4k3l2m1n0e786e8c8b9b5e9c8f1d6"
}

# Add hashes (modifies req in place)
req.add_hashes(hashes)

# Format with hashes for pip
line_with_hashes = req.as_line()
print(line_with_hashes)
# "requests==2.25.0 --hash=sha256:e786e8c8b9b5e9c8f1d6a9b8c7d6e5f4a3b2c1d0e9f8g7h6i5j4k3l2m1n0 --hash=sha256:f9f8e7d6c5b4a3b2c1d0e9f8g7h6i5j4k3l2m1n0e786e8c8b9b5e9c8f1d6"

Install with Tessl CLI