Fix torch/PyTorch introspection compatibility

Add C-side callback name registry so erlang module's __getattr__ only
returns ErlangFunction wrappers for registered callbacks, not arbitrary
attributes. Fixes "erlang.Function has no attribute 'endswith'" error.

Bump version to 1.3.2

Author: benoitc

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.3.2 (2026-02-17)
+
+### Fixed
+
+- **torch/PyTorch introspection compatibility** - Fixed `AttributeError: 'erlang.Function'
+  object has no attribute 'endswith'` when importing torch or sentence_transformers in
+  contexts where erlang_python callbacks are registered.
+  - Root cause: torch does dynamic introspection during import, iterating through Python's
+    namespace and calling `.endswith()` on objects. The `erlang` module's `__getattr__` was
+    returning `ErlangFunction` wrappers for *any* attribute access.
+  - Solution: Added C-side callback name registry. Now `__getattr__` only returns
+    `ErlangFunction` wrappers for actually registered callbacks. Unregistered attributes
+    raise `AttributeError` (normal Python behavior).
+  - New test: `test_callback_name_registry` in `py_reentrant_SUITE.erl`
+
 ## 1.3.1 (2026-02-16)
 
 ### Fixed

c_src/py_callback.c

@@ -83,6 +83,169 @@
  * @note This file is included from py_nif.c (single compilation unit)
  */
 
+/* ============================================================================
+ * Callback Name Registry
+ *
+ * Maintains a C-side registry of registered callback function names.
+ * This allows erlang_module_getattr to only return ErlangFunction wrappers
+ * for actually registered functions, preventing introspection issues with
+ * libraries like torch that probe module attributes.
+ * ============================================================================ */
+
+/**
+ * @def CALLBACK_REGISTRY_BUCKETS
+ * @brief Number of hash buckets for the callback registry
+ */
+#define CALLBACK_REGISTRY_BUCKETS 64
+
+/**
+ * @struct callback_name_entry_t
+ * @brief Entry in the callback name registry hash table
+ */
+typedef struct callback_name_entry {
+    char *name;                        /**< Callback name (owned) */
+    size_t name_len;                   /**< Length of name */
+    struct callback_name_entry *next;  /**< Next entry in bucket chain */
+} callback_name_entry_t;
+
+/** @brief Hash table buckets for callback registry */
+static callback_name_entry_t *g_callback_registry[CALLBACK_REGISTRY_BUCKETS] = {NULL};
+
+/** @brief Mutex protecting the callback registry */
+static pthread_mutex_t g_callback_registry_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/**
+ * @brief Simple hash function for callback names
+ */
+static unsigned int callback_name_hash(const char *name, size_t len) {
+    unsigned int hash = 5381;
+    for (size_t i = 0; i < len; i++) {
+        hash = ((hash << 5) + hash) + (unsigned char)name[i];
+    }
+    return hash % CALLBACK_REGISTRY_BUCKETS;
+}
+
+/**
+ * @brief Check if a callback name is registered
+ *
+ * Thread-safe lookup in the callback registry.
+ *
+ * @param name Callback name to check
+ * @param len Length of name
+ * @return true if registered, false otherwise
+ */
+static bool is_callback_registered(const char *name, size_t len) {
+    unsigned int bucket = callback_name_hash(name, len);
+    bool found = false;
+
+    pthread_mutex_lock(&g_callback_registry_mutex);
+
+    callback_name_entry_t *entry = g_callback_registry[bucket];
+    while (entry != NULL) {
+        if (entry->name_len == len && memcmp(entry->name, name, len) == 0) {
+            found = true;
+            break;
+        }
+        entry = entry->next;
+    }
+
+    pthread_mutex_unlock(&g_callback_registry_mutex);
+    return found;
+}
+
+/**
+ * @brief Register a callback name
+ *
+ * Thread-safe addition to the callback registry.
+ *
+ * @param name Callback name to register
+ * @param len Length of name
+ * @return 0 on success, -1 on failure
+ */
+static int register_callback_name(const char *name, size_t len) {
+    /* Check if already registered */
+    if (is_callback_registered(name, len)) {
+        return 0;  /* Already registered, success */
+    }
+
+    /* Allocate new entry */
+    callback_name_entry_t *entry = enif_alloc(sizeof(callback_name_entry_t));
+    if (entry == NULL) {
+        return -1;
+    }
+
+    entry->name = enif_alloc(len + 1);
+    if (entry->name == NULL) {
+        enif_free(entry);
+        return -1;
+    }
+
+    memcpy(entry->name, name, len);
+    entry->name[len] = '\0';
+    entry->name_len = len;
+
+    unsigned int bucket = callback_name_hash(name, len);
+
+    pthread_mutex_lock(&g_callback_registry_mutex);
+
+    entry->next = g_callback_registry[bucket];
+    g_callback_registry[bucket] = entry;
+
+    pthread_mutex_unlock(&g_callback_registry_mutex);
+
+    return 0;
+}
+
+/**
+ * @brief Unregister a callback name
+ *
+ * Thread-safe removal from the callback registry.
+ *
+ * @param name Callback name to unregister
+ * @param len Length of name
+ */
+static void unregister_callback_name(const char *name, size_t len) {
+    unsigned int bucket = callback_name_hash(name, len);
+
+    pthread_mutex_lock(&g_callback_registry_mutex);
+
+    callback_name_entry_t **pp = &g_callback_registry[bucket];
+    while (*pp != NULL) {
+        callback_name_entry_t *entry = *pp;
+        if (entry->name_len == len && memcmp(entry->name, name, len) == 0) {
+            *pp = entry->next;
+            enif_free(entry->name);
+            enif_free(entry);
+            break;
+        }
+        pp = &entry->next;
+    }
+
+    pthread_mutex_unlock(&g_callback_registry_mutex);
+}
+
+/**
+ * @brief Clean up the callback registry
+ *
+ * Frees all entries. Called during NIF unload.
+ */
+static void cleanup_callback_registry(void) {
+    pthread_mutex_lock(&g_callback_registry_mutex);
+
+    for (int i = 0; i < CALLBACK_REGISTRY_BUCKETS; i++) {
+        callback_name_entry_t *entry = g_callback_registry[i];
+        while (entry != NULL) {
+            callback_name_entry_t *next = entry->next;
+            enif_free(entry->name);
+            enif_free(entry);
+            entry = next;
+        }
+        g_callback_registry[i] = NULL;
+    }
+
+    pthread_mutex_unlock(&g_callback_registry_mutex);
+}
+
 /* ============================================================================
  * Suspended state management
  * ============================================================================ */
@@ -1061,10 +1224,29 @@ static PyObject *ErlangFunction_call(ErlangFunctionObject *self, PyObject *args,
 
 /**
  * Module __getattr__ - enables "from erlang import func_name" and "erlang.func_name()"
+ *
+ * Only returns ErlangFunction wrapper for REGISTERED callback names.
+ * This prevents torch and other libraries that introspect module attributes
+ * from getting callable objects for arbitrary attribute names.
  */
 static PyObject *erlang_module_getattr(PyObject *module, PyObject *name) {
     (void)module;  /* Unused */
-    /* Return an ErlangFunction wrapper for any attribute access */
+
+    /* Get the name as a C string */
+    const char *name_str = PyUnicode_AsUTF8(name);
+    if (name_str == NULL) {
+        return NULL;  /* Exception already set */
+    }
+    size_t name_len = strlen(name_str);
+
+    /* Check if this callback is registered */
+    if (!is_callback_registered(name_str, name_len)) {
+        PyErr_Format(PyExc_AttributeError,
+            "module 'erlang' has no attribute '%s'", name_str);
+        return NULL;
+    }
+
+    /* Return an ErlangFunction wrapper for registered callbacks */
     return ErlangFunction_New(name);
 }
 
@@ -1716,3 +1898,72 @@ static ERL_NIF_TERM nif_resume_callback_dirty(ErlNifEnv *env, int argc, const ER
 
     return result;
 }
+
+/* ============================================================================
+ * NIF functions for callback name registration
+ * ============================================================================ */
+
+/**
+ * @brief NIF to register a callback name in the C-side registry
+ *
+ * This allows the erlang module's __getattr__ to return ErlangFunction
+ * wrappers only for registered callbacks, preventing introspection issues.
+ *
+ * Args: Name (binary or atom)
+ * Returns: ok | {error, Reason}
+ */
+static ERL_NIF_TERM nif_register_callback_name(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    (void)argc;
+
+    ErlNifBinary name_bin;
+    char atom_buf[256];
+
+    const char *name;
+    size_t name_len;
+
+    if (enif_inspect_binary(env, argv[0], &name_bin)) {
+        name = (const char *)name_bin.data;
+        name_len = name_bin.size;
+    } else if (enif_get_atom(env, argv[0], atom_buf, sizeof(atom_buf), ERL_NIF_LATIN1)) {
+        name = atom_buf;
+        name_len = strlen(atom_buf);
+    } else {
+        return make_error(env, "invalid_name");
+    }
+
+    if (register_callback_name(name, name_len) < 0) {
+        return make_error(env, "registration_failed");
+    }
+
+    return ATOM_OK;
+}
+
+/**
+ * @brief NIF to unregister a callback name from the C-side registry
+ *
+ * Args: Name (binary or atom)
+ * Returns: ok
+ */
+static ERL_NIF_TERM nif_unregister_callback_name(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    (void)argc;
+
+    ErlNifBinary name_bin;
+    char atom_buf[256];
+
+    const char *name;
+    size_t name_len;
+
+    if (enif_inspect_binary(env, argv[0], &name_bin)) {
+        name = (const char *)name_bin.data;
+        name_len = name_bin.size;
+    } else if (enif_get_atom(env, argv[0], atom_buf, sizeof(atom_buf), ERL_NIF_LATIN1)) {
+        name = atom_buf;
+        name_len = strlen(atom_buf);
+    } else {
+        return make_error(env, "invalid_name");
+    }
+
+    unregister_callback_name(name, name_len);
+
+    return ATOM_OK;
+}

c_src/py_nif.c

@@ -1708,7 +1708,9 @@ static int upgrade(ErlNifEnv *env, void **priv_data, void **old_priv_data,
 static void unload(ErlNifEnv *env, void *priv_data) {
     (void)env;
     (void)priv_data;
-    /* Cleanup handled by finalize */
+    /* Clean up callback name registry */
+    cleanup_callback_registry();
+    /* Other cleanup handled by finalize */
 }
 
 static ErlNifFunc nif_funcs[] = {
@@ -1776,7 +1778,11 @@ static ErlNifFunc nif_funcs[] = {
     {"thread_worker_signal_ready", 1, nif_thread_worker_signal_ready, 0},
 
     /* Async callback support (for erlang.async_call) */
-    {"async_callback_response", 3, nif_async_callback_response, 0}
+    {"async_callback_response", 3, nif_async_callback_response, 0},
+
+    /* Callback name registry (prevents torch introspection issues) */
+    {"register_callback_name", 1, nif_register_callback_name, 0},
+    {"unregister_callback_name", 1, nif_unregister_callback_name, 0}
 };
 
 ERL_NIF_INIT(py_nif, nif_funcs, load, NULL, upgrade, unload)

src/erlang_python.app.src

@@ -1,6 +1,6 @@
 {application, erlang_python, [
     {description, "Execute Python applications from Erlang using dirty NIFs"},
-    {vsn, "1.3.1"},
+    {vsn, "1.3.2"},
     {registered, [py_pool]},
     {mod, {erlang_python_app, []}},
     {applications, [

src/py_callback.erl

@@ -62,17 +62,24 @@ init_tab() ->
     ok.
 
 %% @doc Register a function to be callable from Python.
+%% Also registers the name in the C-side registry so Python's erlang module
+%% __getattr__ will return an ErlangFunction wrapper for this name.
 -spec register(Name :: atom() | binary(), Fun :: fun((list()) -> term()) | {atom(), atom()}) -> ok.
 register(Name, Fun) ->
     NameBin = to_binary(Name),
     ets:insert(?TABLE, {NameBin, Fun}),
+    %% Register name in C-side registry for Python __getattr__
+    py_nif:register_callback_name(NameBin),
     ok.
 
 %% @doc Unregister a function.
+%% Also unregisters the name from the C-side registry.
 -spec unregister(Name :: atom() | binary()) -> ok.
 unregister(Name) ->
     NameBin = to_binary(Name),
     ets:delete(?TABLE, NameBin),
+    %% Unregister name from C-side registry
+    py_nif:unregister_callback_name(NameBin),
     ok.
 
 %% @doc Lookup a registered function.

src/py_nif.erl

@@ -65,7 +65,10 @@
     thread_worker_write/2,
     thread_worker_signal_ready/1,
     %% Async callback support (for erlang.async_call)
-    async_callback_response/3
+    async_callback_response/3,
+    %% Callback name registry (prevents torch introspection issues)
+    register_callback_name/1,
+    unregister_callback_name/1
 ]).
 
 -on_load(load_nif/0).
@@ -401,3 +404,20 @@ thread_worker_signal_ready(_Fd) ->
     ok | {error, term()}.
 async_callback_response(_Fd, _CallbackId, _Response) ->
     ?NIF_STUB.
+
+%%% ============================================================================
+%%% Callback Name Registry
+%%% ============================================================================
+
+%% @doc Register a callback name in the C-side registry.
+%% This allows the Python erlang module's __getattr__ to return
+%% ErlangFunction wrappers only for registered callbacks, preventing
+%% introspection issues with libraries like torch.
+-spec register_callback_name(atom() | binary()) -> ok | {error, term()}.
+register_callback_name(_Name) ->
+    ?NIF_STUB.
+
+%% @doc Unregister a callback name from the C-side registry.
+-spec unregister_callback_name(atom() | binary()) -> ok.
+unregister_callback_name(_Name) ->
+    ?NIF_STUB.