# --- ctypes : appeler des bibliotheques C existantes sans les recompiler ---
import ctypes

# Charger la libc et appeler une fonction C standard
libc = ctypes.CDLL(None)              # None charge la libc du systeme
libc.printf(b"Hello depuis C via ctypes : %d\n", 42)

# Definir les types d'arguments/retour pour la securite et la correction
libm = ctypes.CDLL("libm.so.6" if ctypes.util is not None else None) if False else None
# (exemple illustratif : le chargement precis depend de l'OS)

class Point(ctypes.Structure):
    # Mapper une structure C directement en Python
    _fields_ = [("x", ctypes.c_double), ("y", ctypes.c_double)]

p = Point(1.5, 2.5)
print(p.x, p.y)

# --- cffi / ctypes pour wrapper une lib partagee custom ---
# supposons libcalcul.so compilee depuis :
#   double distance(double x1, double y1, double x2, double y2) { ... }
#
# lib = ctypes.CDLL("./libcalcul.so")
# lib.distance.argtypes = [ctypes.c_double] * 4
# lib.distance.restype = ctypes.c_double
# resultat = lib.distance(0, 0, 3, 4)     # 5.0

# --- Cython : le pont le plus utilise en production (NumPy, pandas l'utilisent) ---
# fichier calcul.pyx :
'''
def fibonacci_cython(int n):
    cdef long a = 0
    cdef long b = 1
    cdef int i
    for i in range(n):
        a, b = b, a + b
    return a

def somme_carres(int n):
    cdef long total = 0
    cdef int i
    for i in range(n):
        total += i * i
    return total
'''

# fichier setup.py pour compiler l'extension Cython :
'''
from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules=cythonize("calcul.pyx", compiler_directives={"language_level": "3"}),
)
'''

# Compilation puis usage :
# $ python setup.py build_ext --inplace
# >>> from calcul import fibonacci_cython
# >>> fibonacci_cython(30)     # 10 a 50x plus rapide que l'equivalent Python pur

# --- L'API C de CPython : ecrire une extension native en C ---
# fichier module.c (simplifie, sans gestion d'erreur complete) :
'''
#include <Python.h>

static PyObject* addition(PyObject* self, PyObject* args) {
    int a, b;
    if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
        return NULL;
    }
    return PyLong_FromLong(a + b);
}

static PyMethodDef Methods[] = {
    {"addition", addition, METH_VARARGS, "Additionne deux entiers"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef monmodule = {
    PyModuleDef_HEAD_INIT, "monmodule", NULL, -1, Methods
};

PyMODINIT_FUNC PyInit_monmodule(void) {
    return PyModule_Create(&monmodule);
}
'''

# --- Alternative moderne : PyO3 (Rust) ---
# de plus en plus utilise en production (ex: certaines parties de pydantic v2, polars)
# offre la securite memoire de Rust avec des performances proches du C

# --- multiprocessing.shared_memory : partager de gros buffers sans copie ---
from multiprocessing import shared_memory
import numpy as np

# creation d'un buffer partage entre processus (evite la serialisation couteuse)
shm = shared_memory.SharedMemory(create=True, size=1024)
tableau_partage = np.ndarray((128,), dtype=np.float64, buffer=shm.buf)
tableau_partage[:] = 0
shm.close()
shm.unlink()