Introduction
If you're working on scientific calculations using C programming, you might find it tedious to prepare an interface to call it from Python. However, Codeoven offers a simple solution to this problem. All you have to do is add some comment lines to the original C source code, and Codeoven will do the rest. By decorating your code with @oven comment lines, the code will be compiled and executed so that it can communicate with your Python script through stdio.
Using Codeoven eliminates the need to prepare a separate interface to link your C code with Python. Instead, the @oven comment lines act as a bridge between the two programming languages. This approach has the added advantage of allowing the original source code to be run in any IDE, making debugging easier.
Here is a quick example.
Assume that we have a source code main.c that adds up from 1 to n.
#include <stdio.h>
int main(void)
{
int i, total = 0;
int n = 1; // @oven
for(i = 1; i <= n; i++)
{
total += i;
}
printf("answer:%d\n", total); // @oven
return 0;
}
The following Python script will compile and run main.c to get the sum of 1 to 10.
from codeoven import Oven
oven = Oven("main.c")
result = oven.run({"n": 10})
print(result["answer"]) # -> print 55
Notice that the only modification required to the source code is the @oven comments on the lines corresponding to input and output.
In terms of the execution speed, the initial compilation and the communication between C and Python through stdio would be the major bottleneck.
Usage
Loading your source code
oven = Oven("main.c")
Running your program
parameter_dict = {"a": 1, "b": 2.0, "c": [3.0, 4.0, 5.0]}
result = oven.run(parameter_dict)
Passing values from Python to C
Passing a scalar value
// At declaration
int a = 1; // @oven
//At substitution
double b;
b = 2; // @oven
Passing an array
double c[] = {0.0};
Passing value from C to Python
You can output the results of your calculation using printf:
printf("key_name:%lf\n", value); // @oven
The format string must always be composed of a sequence of a key, a colon, a value, and a newline. As for the value, it can be a number, string tuple list, or dictionary, as long as it can be evaluated by Python's ast.literal_eval.
printf("a_and_b:(%d, %lf)\n", a, b); // @oven
// This line passes
printf("time_series:(%d, %lf)\n", 0, x); // @oven
for(i = 0; i < n; i++)
x += calculation(i, x);
printf("time_series:(%d, %lf)\n", i+1, x); // @oven
If multiple outputs are made for the same key, the result is a list in the order of outputs.
Accessing the results
The return value of run is a dictionary. You can access it as usual.
print(result["a"])
Code modifiers
@oven
Input
int n = 1; // @oven
double array[] = {1.0, 2.0, 3.0}; // @oven
Output
printf("result:%d\n", n*n); // @oven
(Plan)@oven.assign (new plan)-> @oven.as: or @oven:
Assign the value using a Python statement.
int array[] = {2, 3, 5}; // @oven
int n = 3; // @oven.assign:array.size
double map[][] = {{1.0, 2.0}, {2.0, 3.0}, {3.0, 4.0}}; // @oven
int n_x = 2; // @oven.assign:map.shape[0]
int n_y = 3; // @oven.assign:map.shape[1]
@oven.compile
The input specified by @oven.compile is embdedded directrly in the source code.
int n = 1; // @oven.compile
double array[] = {1.0, 2.0}; // @oven.compile
int n = 2; // @oven.assign:array.size
Reference
class codeoven.Oven
codeoven.Oven(file_name:str)
file_name: The file name of a source code to be processed
When an instance of Oven is created, the source code is loaded and parsed. At this stage, no new code is written out yet; the oven instance generates code when run or burn is executed.
oven.run(parameters:dict=None) -> dict
parameters: Initialization or substitution statements commented with "@oven" in the C source code will be replaced using the value of the dictionary at runtime though stdin. The compilation will be done once for the first execution.
oven.burn(parameters:dict=None) -> dict
parameters: Initialization or substitution statements commented with "@oven" in the C source code will be replaced using the value of the dictionary.
Each time the method burn is called, the new source code is output, compiled, and executed. No information exchange will be done at runtime, and all the parameters and data will be implemented in the source code.
Examples
#include <stdio.h>
int main(void)
{
double data[] = [1, 3, 5]; // @oven
int n = 3; // @over:data.size
double result = 0;
int i;
for (i = 0; i < n; i++)
{
result += data[i];
}
printf("sum:%lf\n", result); // @oven
return 0
}
#include <stdio.h>
int main(void)
{
double data = [[1, 2, 3], [2, 3, 4]]; // @oven.runtime
int imax = 3; // @oven.assign:data.shape[0]
int kmax = 2; // @oven.assign:data.shape[1]
int i, k;
for (i = 0; i <)
}
Metadata
Release files for codeoven 0.1.4
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| codeoven-0.1.4.tar.gz | 11.2 kB | Without provenance | Details for codeoven-0.1.4.tar.gz |
Release files / codeoven-0.1.4.tar.gz
| Download URL | codeoven-0.1.4.tar.gz |
|---|---|
| Size | 11.2 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
f1609ef0d7eab7697e781002be7c68738d21955b841b8b3f1854c9169fc3332d
|
|
BLAKE2b-256 checksum How to use checksums |
f7eeddd857638a2b113d2adc867c56f767fac14edf10f45019f543e43277abcd
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/4.0.2 CPython/3.9.16
|
Security for codeoven 0.1.4
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.