Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/robinvandernoord/comptime
"Zig into Python's speed lane with Comptime – it's not a sprint; it's a compile!"
https://github.com/robinvandernoord/comptime
ast compiler comptime python zig
Last synced: 27 days ago
JSON representation
"Zig into Python's speed lane with Comptime – it's not a sprint; it's a compile!"
- Host: GitHub
- URL: https://github.com/robinvandernoord/comptime
- Owner: robinvandernoord
- License: mit
- Created: 2023-08-10T12:45:47.000Z (about 1 year ago)
- Default Branch: master
- Last Pushed: 2023-08-15T13:30:56.000Z (about 1 year ago)
- Last Synced: 2024-09-29T02:01:55.001Z (about 1 month ago)
- Topics: ast, compiler, comptime, python, zig
- Language: Python
- Homepage: https://pypi.org/project/comptime
- Size: 42 KB
- Stars: 1
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
# comptime
"Comptime" accelerates Python code by precomputing complex calculations, turning them into simple lookups for faster
execution.
-----
**Table of Contents**
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
Comptime is inspired by the concept of compile-time computation found in languages
like [Zig](https://ziglang.org/documentation/master/#comptime), and it brings this powerful
feature into the world of Python, an interpreted language. By utilizing special decorators, you can mark functions whose
return values should be precomputed. This enables you to separate computationally expensive parts of your code,
performing those calculations once, and embedding the results directly into your source code. The result is Python code
that executes faster by turning complex calculations into simple lookups. Whether you're optimizing critical performance
bottlenecks or exploring new ways to structure your code, Comptime offers a novel approach to accelerate your Python
development.
**"Zig into Python's speed lane with Comptime – it's not a sprint; it's a compile!"**
## :warning: Warning: this is only a proof-of-concept
This code was only created to test the concept. It should NOT be used in a production environment, as I can not
guarantee at this time that the semantics of the outputted code are correct.
Furthermore, initial performance tests show that for relatively simple calculations, this does NOT actually improve
performance:
```bash
python examples/perf.py # pre-comptime:
# Function executed in: 2.0992 seconds total; avg of 209.92 ns. per execution.
python examples/perf_match.py # comptime with match-case strategy:
# Function executed in: 21.5824 seconds total; avg of 2158.24 ns. per execution.
python examples/perf_dict.py # comptime with dict lookup strategy:
# Function executed in: 152.4098 seconds total; avg of 15240.98 ns. per execution.
```
While this package could be useful in cases where the calculation is actually heavy, it could also negatively impact
your performance!
## Installation
```console
pip install comptime
```
## Usage
```python
# src_raw/main.py: before comptime
from comptime import comptime
@comptime.skip
def nonpure_method():
# this method has side effects so should only be used at runtime
print("e.g. sending an email")
@comptime
def my_method():
...
# some expensive calculations
nonpure_method() # not executed due to @comptime.skip
return 41 + 1
@comptime("users", "posts")
def call_api(endpoint):
# api get value for endpoint
...
return value
call_api("other") # possible comptime warning due to unsupported argument?
```
```bash
comptime --input src_raw --output src_compiled
```
```python
# src_compiled/main.py: after comptime
import typing
def nonpure_method():
# this method has side effects so should only be used at runtime
print("e.g. sending an email")
def my_method():
# computed by comptime
return 42
def call_api(endpoint: typing.Literal["users", "posts"]):
# computed by comptime
match endpoint:
case "users":
return ['user1']
case "posts":
return ['post1']
case _:
raise ValueError("Uncompiled variant {endpoint}")
return value
```
## Acknowledgments
This project owes its inspiration and certain elements of its design to various sources:
- **Zig Programming Language:** The concept of compile-time computation in Comptime is inspired
by [Zig](https://github.com/ziglang/zig), a language that emphasizes safety, performance, and readability. A special
thank you to Zig's creators and community for their innovative approach to programming.
- **GPT-4 by OpenAI:** Assistance with the project boilerplate, creative brainstorming, and crafting the memorable
slogan "Zig into Python's speed lane with Comptime – it's not a sprint; it's a compile!" was provided by GPT-4. It
also wrote this section.
Please note that the author of comptime is not affiliated with Zig, OpenAI, or any other entities mentioned
above. The acknowledgments are expressions of gratitude and inspiration and do not imply any formal association or
endorsement by these parties.
## License
`comptime` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.