tessl/pypi-requirementslib
A tool for converting between pip-style and pipfile requirements.
—
Pending
lockfile.mddocs/
Lockfile Operations
The Lockfile class provides comprehensive functionality for working with Pipfile.lock files to ensure reproducible dependency resolution. It supports loading existing lockfiles, creating new ones from Pipfiles, accessing locked dependencies, and converting to requirements.txt format.
Capabilities
Lockfile Loading and Creation
Load existing lockfiles or create new ones from Pipfiles and raw data.
class Lockfile:
def __init__(self, path=None, projectfile=None, lockfile=None, **kwargs):
"""
Initialize Lockfile object.
Parameters:
- path: Path to Pipfile.lock
- projectfile: ProjectFile instance
- lockfile: Internal lockfile object
"""
@classmethod
def load(cls, path, create=True):
"""
Load lockfile from path.
Parameters:
- path: Path to Pipfile.lock
- create: Whether to create if not exists
Returns:
Lockfile object
"""
@classmethod
def create(cls, path, create=True):
"""
Create new lockfile.
Parameters:
- path: Path for new lockfile
- create: Whether to create if not exists
Returns:
Lockfile object
"""
@classmethod
def from_data(cls, path, data, meta_from_project=True):
"""
Create from data dictionary.
Parameters:
- path: Path for lockfile
- data: Lockfile data dictionary
- meta_from_project: Use project metadata
Returns:
Lockfile object
"""
@classmethod
def lockfile_from_pipfile(cls, pipfile_path):
"""
Create lockfile from Pipfile.
Parameters:
- pipfile_path: Path to Pipfile
Returns:
Lockfile object
"""
@classmethod
def read_projectfile(cls, path):
"""
Read project file from path.
Parameters:
- path: Path to project file
Returns:
ProjectFile object
"""
@classmethod
def load_projectfile(cls, path=None, create=True, data=None):
"""
Load project file.
Parameters:
- path: Path to project file
- create: Whether to create if not exists
- data: Project file data
Returns:
ProjectFile object
"""Core Properties
Access lockfile metadata, paths, and section information.
class Lockfile:
@property
def path(self) -> Path:
"""Path to lockfile"""
@property
def projectfile(self) -> ProjectFile:
"""Project file instance"""
@property
def lockfile(self) -> lockfiles.Lockfile:
"""Internal lockfile object"""
@property
def newlines(self) -> str:
"""Line ending style"""
@property
def section_keys(self) -> set:
"""Available section keys (excluding _meta)"""
@property
def extended_keys(self) -> List:
"""Extended section keys"""
@property
def develop(self) -> Dict:
"""Development dependencies section"""
@property
def default(self) -> Dict:
"""Default dependencies section"""Dependency Access
Access locked dependencies and convert them to Requirement objects.
class Lockfile:
def get_requirements(self, dev: bool = True, only: bool = False, categories: Optional[List[str]] = None):
"""
Get requirements iterator.
Parameters:
- dev: Include development dependencies
- only: Only return specified categories
- categories: Specific categories to include
Returns:
Iterator[Requirement]: Requirements iterator
"""
def requirements_list(self, category: str):
"""
Get requirements as list.
Parameters:
- category: Category name ("default" or "develop")
Returns:
List[Dict]: Requirements data list
"""
def get_deps(self, dev=False, only=True):
"""
Get dependencies dictionary.
Parameters:
- dev: Include development dependencies
- only: Only return specified category
Returns:
Dict: Dependencies dictionary
"""
def get_section(self, name: str):
"""
Get named section.
Parameters:
- name: Section name
Returns:
Optional[Dict]: Section data or None
"""Format Conversion
Convert lockfile dependencies to requirements.txt format and write lockfiles to disk.
class Lockfile:
def as_requirements(self, category: str, include_hashes=False):
"""
Format as requirements.txt lines.
Parameters:
- category: Category name ("default" or "develop")
- include_hashes: Whether to include package hashes
Returns:
List[str]: Requirements.txt formatted lines
"""
def write(self) -> None:
"""Write lockfile to disk."""Data Access
Access lockfile data using dictionary-like interface.
class Lockfile:
def get(self, k):
"""
Get item by key.
Parameters:
- k: Key to retrieve
Returns:
Value for key
"""
def __contains__(self, k):
"""
Check if key exists.
Parameters:
- k: Key to check
Returns:
bool: True if key exists
"""
def __getitem__(self, k, *args, **kwargs):
"""
Get item by key using bracket notation.
Parameters:
- k: Key to retrieve
Returns:
Value for key
"""
def __setitem__(self, k, v):
"""
Set item by key using bracket notation.
Parameters:
- k: Key to set
- v: Value to set
"""
def __getattr__(self, k, *args, **kwargs):
"""
Get attribute by name.
Parameters:
- k: Attribute name
Returns:
Attribute value
"""Usage Examples
Loading Lockfiles
from requirementslib import Lockfile
# Load existing lockfile
lockfile = Lockfile.load("./Pipfile.lock")
# Load lockfile with creation if missing
lockfile = Lockfile.load("./Pipfile.lock", create=True)
# Create lockfile from Pipfile
lockfile = Lockfile.lockfile_from_pipfile("./Pipfile")
# Create from data dictionary
lockfile_data = {
"default": {
"requests": {
"version": "==2.25.0",
"hashes": ["sha256:..."]
}
},
"develop": {},
"_meta": {
"requires": {"python_version": "3.8"}
}
}
lockfile = Lockfile.from_data("./Pipfile.lock", lockfile_data)Accessing Dependencies
from requirementslib import Lockfile
# Load lockfile
lockfile = Lockfile.load("./Pipfile.lock")
# Get all requirements (production and development)
for req in lockfile.get_requirements():
print(f"{req.name}: {req.specifiers}")
# Get only production requirements
for req in lockfile.get_requirements(dev=False, only=True):
print(f"Production: {req.name} {req.specifiers}")
# Get only development requirements
for req in lockfile.get_requirements(dev=True, only=True):
print(f"Development: {req.name} {req.specifiers}")
# Access raw dependency data
default_deps = lockfile.default
develop_deps = lockfile.develop
print("Default dependencies:", default_deps)
print("Development dependencies:", develop_deps)Converting to Requirements.txt
from requirementslib import Lockfile
# Load lockfile
lockfile = Lockfile.load("./Pipfile.lock")
# Convert production dependencies to requirements.txt format
prod_requirements = lockfile.as_requirements("default")
for line in prod_requirements:
print(line)
# Convert with hashes for integrity verification
prod_requirements_with_hashes = lockfile.as_requirements("default", include_hashes=True)
for line in prod_requirements_with_hashes:
print(line)
# Convert development dependencies
dev_requirements = lockfile.as_requirements("develop")
for line in dev_requirements:
print(line)
# Write to files
with open("requirements.txt", "w") as f:
f.write("\n".join(lockfile.as_requirements("default")))
with open("requirements-dev.txt", "w") as f:
f.write("\n".join(lockfile.as_requirements("develop")))Working with Sections
from requirementslib import Lockfile
# Load lockfile
lockfile = Lockfile.load("./Pipfile.lock")
# Access available sections
print("Available sections:", lockfile.section_keys)
# Get specific section
default_section = lockfile.get_section("default")
develop_section = lockfile.get_section("develop")
print("Default section data:", default_section)
print("Develop section data:", develop_section)
# Access metadata
if "_meta" in lockfile:
meta = lockfile["_meta"]
print("Lockfile metadata:", meta)
if "requires" in meta:
python_version = meta["requires"].get("python_version")
print(f"Required Python version: {python_version}")Modifying and Writing Lockfiles
from requirementslib import Lockfile
# Load lockfile
lockfile = Lockfile.load("./Pipfile.lock")
# Modify lockfile data (if needed)
lockfile["default"]["new-package"] = {
"version": "==1.0.0",
"hashes": ["sha256:abcd1234..."]
}
# Write modified lockfile back to disk
lockfile.write()
# Access requirements after modification
for req in lockfile.get_requirements():
print(f"Updated lockfile contains: {req.name} {req.specifiers}")Working with Hashes
from requirementslib import Lockfile
# Load lockfile
lockfile = Lockfile.load("./Pipfile.lock")
# Check for packages with hashes
for req in lockfile.get_requirements():
if req.hashes:
print(f"{req.name} has {len(req.hashes)} hashes")
for hash_val in req.hashes:
print(f" {hash_val}")
# Convert to requirements.txt with hashes for verification
requirements_with_hashes = lockfile.as_requirements("default", include_hashes=True)
print("Requirements with hashes:")
for line in requirements_with_hashes:
print(line)Install with Tessl CLI
npx tessl i tessl/pypi-requirementslib