---

title: “Spectomate - Python Package Management Format Converter” description: “A tool for converting projects between different Python package management formats (pip, conda, poetry)” author: “Tom Sapletta” keywords: “python, package management, pip, conda, poetry, converter, requirements.txt, environment.yml, pyproject.toml” lang: “en” image: “https://github.com/spectomate/python/raw/main/docs/diagrams/logo.png” —

Spectomate

Spectomate is a tool for converting projects between different Python package management formats (pip, conda, poetry).

Key Features of Spectomate:

1. Modular architecture - each converter is a separate module implementing a common interface
2. Support for existing tools - ability to integrate with external conversion tools
3. Flexible extension system - easy addition of new converters without modifying the base code
4. Comprehensive format support:
   • pip (requirements.txt)
   • conda (environment.yml)
   • poetry (pyproject.toml)
5. Project management tools:
   • Package version updating
   • Testing and linting automation
   • Publication to PyPI

Installation

# Basic installation
pip install spectomate

How to Use Spectomate:

Command Line Interface (CLI)

Format Conversion

# Display available converters
spectomate --list

# Convert from pip to conda
spectomate -s pip -t conda -i requirements.txt -o environment.yml --env-name myproject

# Convert from conda to pip
spectomate -s conda -t pip -i environment.yml -o requirements.txt

# Convert from pip to poetry
spectomate -s pip -t poetry -i requirements.txt -o pyproject.toml --project-name "my-project" --version "0.1.0"

Package Update and Management

# Full package update with publication
spectomate update

# Interactive update with project analysis
spectomate update --interactive

# Only analyze project without updating
spectomate update --analyze-only

# Update without publishing to PyPI
spectomate update --no-publish

# Update without type checking
spectomate update --no-mypy

# Update without running tests
spectomate update --no-test

# Update without linting
spectomate update --no-lint

# Update without checking Git submodules
spectomate update --no-submodules

# Update with verbose output
spectomate update --verbose

Programmatic Usage

from spectomate.converters.pip_to_conda import PipToCondaConverter

# Convert from pip to conda
converter = PipToCondaConverter(
    source_file="requirements.txt",
    target_file="environment.yml",
    options={"env_name": "myproject"}
)
result_path = converter.execute()
print(f"Output file: {result_path}")

Project Structure

spectomate/
├── __init__.py                  # Package initialization
├── cli.py                       # Command line interface
├── core/                        # Core components
│   ├── __init__.py
│   ├── base_converter.py        # Base class for converters
│   ├── registry.py              # Converter registration system
│   └── utils.py                 # Helper functions
├── converters/                  # Converter implementations
│   ├── __init__.py
│   ├── conda_to_pip.py          # Converter from conda to pip
│   ├── pip_to_conda.py          # Converter from pip to conda
│   ├── pip_to_poetry.py         # Converter from pip to poetry
│   └── ...
└── schemas/                     # Data schemas for formats
    ├── __init__.py
    ├── conda_schema.py          # Schema for conda format
    ├── pip_schema.py            # Schema for pip format
    ├── poetry_schema.py         # Schema for poetry format
    └── ...

Documentation

Detailed documentation is available in the docs/ directory:

• Architecture - description of the system architecture
• Converters - description of available converters and their implementation
• Schemas - description of data schemas for different formats

Diagrams

Visual documentation in the form of Mermaid diagrams:

• Architecture Diagram - class structure and relationships between components
• Data Flow Diagram - data flow during the conversion process
• Sequence Diagram - interactions between components during conversion
• Extension Diagram - process of adding new converters and formats

Note: Polish documentation is available in the docs/pl/ directory.

Extending Spectomate

Spectomate is designed as a modular system that can be easily extended with new formats and converters. To add a new converter:

1. Create a new converter class inheriting from BaseConverter
2. Implement the required abstract methods:
   • get_source_format() - returns the source format identifier
   • get_target_format() - returns the target format identifier
   • read_source() - reads the source file
   • convert() - converts the data
   • write_target() - writes the data to the target file
3. Register the converter using the @register_converter decorator

Detailed information on creating custom converters can be found in the converters documentation.

License

This project is licensed under the Apache 2 License