PyO3/pyo3
Pyo3
This project provides a framework for binding Rust and Python, enabling the creation of native extension modules and the embedding of the Python interpreter within host applications. It functions as a cross-language interoperability library that facilitates the execution of scripts, the definition of classes, and the sharing of data structures across the boundary of the two runtimes.
The framework distinguishes itself through the use of procedural macros to automate the generation of boilerplate code, simplifying the process of exposing native functions and data types. It employs type-level markers to manage the global interpreter lock and reference-counted containers to handle object lifetimes, ensuring thread safety and memory integrity during cross-language execution. An integrated exception translation layer further ensures that errors are mapped consistently between environments.
The toolset covers a broad range of development needs, including the compilation of native binary extensions, the generation of type stubs for static analysis, and the configuration of build environments to support multiple interpreter versions. It also provides capabilities for bridging logging frameworks and automating the recompilation of modules during development.
The project is distributed as a library that integrates with standard build tools to produce installable binary files.
Features
- Foreign Function Interfaces - Provides a system for mapping data types, managing lifetimes, and translating exceptions between language environments.
- Python Bindings - Provides a comprehensive framework for binding Rust and Python, enabling native extension development and interpreter embedding.
- Extension Compilers - Compiles high-level source code into native binary extension modules for seamless integration with the Python interpreter.
- Python Scripting Environments - Integrates the interpreter directly into host applications to enable dynamic script execution.
- CommonJS Interop - Acts as a bridge for calling functions, defining classes, and sharing data structures across runtimes.
- Scripting Runtimes - Integrates a language interpreter directly into host applications to enable standalone script execution.
- Python Development Tools - Builds high-performance native modules to accelerate computationally intensive tasks.
- Module Development - Exposes performance-critical native logic as importable modules for use in standard scripts.
- Language Interoperability - Maps complex data structures and types between languages to ensure safe and efficient communication.
- Scripting Hosts - Executes scripts and manages objects directly within the host application to integrate external logic.
- Native Build Orchestrators - Compiles source code into native modules and packages them as installable binary files.
- Native System Extensions - Creates native extension modules from compiled code to allow seamless integration with external scripts.
- Global Interpreter Locks - Manages thread safety and runtime state access across language boundaries using type-level markers.
- Procedural Macros - Uses compiler-level annotations to automatically generate boilerplate code for native language bindings.
- Native Class Wrappers - Exposes internal data structures as native classes for instantiation and method invocation from scripts.
- Native Code Exporters - Maps native functions and data structures to compatible interfaces for execution as native modules.
- Foreign Function Invocations - Executes foreign functions and accesses objects by managing cross-language memory references.
- Lifetime Tracking Tokens - Uses type-level tokens to track the global interpreter lock and ensure safe object access.
- Foreign Function Interface - Rust bindings for the Python interpreter.
- Type Mapping Converters - Automatically maps complex data structures and primitive values between language runtimes.
- Native Binary Toolchains - Compiles source code into shared library objects compatible with the host language runtime.
- Script Execution Engines - Executes arbitrary scripts and functions from within a host application to leverage external logic.
- Cross-Language Memory Managers - Uses reference-counted containers to manage object lifetimes and prevent memory leaks during cross-language execution.
- Native Class Mappings - Maps custom data structures to classes to define methods and properties that interact with the host environment.
- Cross-Compilation Toolchains - Configures build environments to target multiple operating systems and hardware architectures.
- Translation Layers - Provides an integrated layer that translates and maps errors between native and foreign language environments.
- Interpreter Internals - Initializes and manages the lifecycle of a language runtime within a host application.
- Module Loaders - Loads external modules into the host environment to access their functionality directly.
- Exception Hierarchies - Translates and propagates errors between language environments using unified exception hierarchies.
- Exception Mappers - Translates native exceptions into corresponding types to maintain consistent error handling across environments.
- Type Definition Generators - Generates type stubs from native code to enable static analysis and IDE autocompletion in external projects.
- Module Preinitializers - Registers custom modules in an internal table to make them available for import within the runtime.
- Type Definition Generators - Generates interface definition files from compiled modules to support static analysis and autocompletion.
