py2cpp 1.7.1

A Python-to-C++ translator.

py2cpp

A Python-to-C++ translator that converts a restricted subset of Python into clean and readable C++ code. It offers both Ahead-of-Time (AOT) compilation through a command-line tool and Just-in-Time (JIT) compilation via a decorator.

Online Simulator

Key Features

• Dual Compilation Modes:
  • Ahead-of-Time (AOT): Convert entire Python files to C++ source code or executables using the py2cpp command-line tool.
  • Just-in-Time (JIT): Use the @jit decorator to compile and run specific Python functions in C++ at runtime for a performance boost.
• Readable C++ Code: Translates Python syntax into human-readable and clean C++ code.
• Type-Hint Driven: Utilizes Python type hints to generate corresponding C++ types.
• C-Style Data Structures: Define C-like structures directly in Python using the @c_struct decorator.
• Fine-Grained Type Control: Provides special types like c_int, c_double, c_char, etc., for precise control over the generated C++ data types.
• Python Interoperability: Allows passing Python objects to and from JIT-compiled functions.

Note:

The actual translation may vary based on the specific implementation details of py2cpp.

This project doesn't optimize your code for performance or memory usage.

Project Goals

1. Provide a static translation layer. (Without using A.I.)
2. Offer a simplified Python-like syntax that maps cleanly to C++ constructs.
3. Covering all python syntax constructs as much as possible.
4. Minimize boilerplate on both the Python input side and the C++ output side.

Installation

pip install py2cpp

Usage

Command-Line Usage (AOT)

The py2cpp command-line tool translates .py files into .cpp files or executables.

# Translate to C++
py2cpp input.py

# Translate to a C++ executable
py2cpp input.py -c exe

# Specify output file
py2cpp input.py -o output.cpp
py2cpp input.py -o output.exe

JIT-Compilation Usage

Use the @jit decorator for on-the-fly compilation and execution of Python functions.

from py2cpp.core.jit import jit

@jit
def add(a: int, b: int) -> int:
    return a + b

# The 'add' function is now a compiled C++ function
result = add(5, 10)
print(result)

Examples

AOT Compilation Example

This Python code:

def add(a: int, b: int) -> int:
    return a + b

x = input()
y = 5

print(add(int(x), y))

translates to this C++ code:

#include <iostream>
#include <string>

long add(long a, long b) {
    return a + b;
}

int main() {
    std::string x;
    std::getline(std::cin, x);
    long y = 5;
    std::cout << add(std::stol(x), y) << std::endl;
    return 0;
}

JIT Compilation Example

Here is a simple example of using the @jit decorator to accelerate a function:

from py2cpp.core.jit import jit
from time import time

@jit
def fast_add(a: int, b: int) -> int:
    n = a
    for _ in range(100000000):
        n += b
    return n

start = time()
result = fast_add(10, 20)
print(f"Result: {result}")
print(f"Execution time: {time() - start:.4f}s")

License

MIT License. See LICENSE file for details.