Make erlang.atom() available in OWN_GIL subinterpreters

Add atom() wrapper with caching directly in C module creation, so it's
available in OWN_GIL contexts where _erlang_impl package isn't imported.

- Add atom_wrapper_code in create_erlang_module() with:
  - _atom_cache dict for memoization
  - _MAX_USER_ATOMS limit (10000) to prevent unbounded growth
  - atom() function that wraps erlang._atom() with caching
- Add 3 new tests: atom_create, atom_create_different, atom_cache
- Add Python helpers for testing erlang.atom() in OWN_GIL mode

Author: benoitc

c_src/py_callback.c

@@ -3958,6 +3958,63 @@ static int create_erlang_module(void) {
         Py_DECREF(ext_globals);
     }
 
+    /* Add atom() wrapper with caching for OWN_GIL subinterpreters.
+     * In OWN_GIL mode, the Python package (_erlang_impl) is not imported,
+     * so erlang.atom() isn't available. This adds it directly to the C module.
+     */
+    const char *atom_wrapper_code =
+        "_atom_cache = {}\n"
+        "_MAX_USER_ATOMS = 10000\n"
+        "def atom(name):\n"
+        "    '''Create or retrieve a cached atom.\n"
+        "    \n"
+        "    Args:\n"
+        "        name: String name for the atom\n"
+        "    \n"
+        "    Returns:\n"
+        "        An erlang.Atom object\n"
+        "    \n"
+        "    Raises:\n"
+        "        RuntimeError: If atom limit (10000) is reached\n"
+        "    '''\n"
+        "    if name in _atom_cache:\n"
+        "        return _atom_cache[name]\n"
+        "    if len(_atom_cache) >= _MAX_USER_ATOMS:\n"
+        "        raise RuntimeError('Atom limit reached')\n"
+        "    import erlang\n"
+        "    result = erlang._atom(name)\n"
+        "    _atom_cache[name] = result\n"
+        "    return result\n"
+        "\n"
+        "import erlang\n"
+        "erlang.atom = atom\n"
+        "erlang._atom_cache = _atom_cache\n";
+
+    PyObject *atom_globals = PyDict_New();
+    if (atom_globals != NULL) {
+        PyObject *builtins = PyEval_GetBuiltins();
+        PyDict_SetItemString(atom_globals, "__builtins__", builtins);
+
+        /* Import erlang module into globals so the code can reference it */
+        PyObject *sys_modules = PySys_GetObject("modules");
+        if (sys_modules != NULL) {
+            PyObject *erlang_mod = PyDict_GetItemString(sys_modules, "erlang");
+            if (erlang_mod != NULL) {
+                PyDict_SetItemString(atom_globals, "erlang", erlang_mod);
+            }
+        }
+
+        PyObject *result = PyRun_String(atom_wrapper_code, Py_file_input, atom_globals, atom_globals);
+        if (result == NULL) {
+            /* Non-fatal - atom() just won't be available */
+            PyErr_Print();
+            PyErr_Clear();
+        } else {
+            Py_DECREF(result);
+        }
+        Py_DECREF(atom_globals);
+    }
+
     return 0;
 }
 

test/py_owngil_features_SUITE.erl

@@ -104,6 +104,9 @@
     owngil_whereis_parallel_test/1,
     owngil_atom_basic_test/1,
     owngil_atom_roundtrip_test/1,
+    owngil_atom_create_test/1,
+    owngil_atom_create_different_test/1,
+    owngil_atom_cache_test/1,
     owngil_ref_roundtrip_test/1,
     owngil_pid_operations_test/1
 ]).
@@ -187,6 +190,9 @@ groups() ->
         owngil_whereis_parallel_test,
         owngil_atom_basic_test,
         owngil_atom_roundtrip_test,
+        owngil_atom_create_test,
+        owngil_atom_create_different_test,
+        owngil_atom_cache_test,
         owngil_ref_roundtrip_test,
         owngil_pid_operations_test
     ]}].
@@ -1660,6 +1666,49 @@ owngil_atom_roundtrip_test(Config) ->
 
     py_context:stop(Ctx).
 
+%% @doc Test erlang.atom() creates equal atoms in owngil context
+owngil_atom_create_test(Config) ->
+    {ok, Ctx} = py_context:start_link(1, owngil),
+    TestDir = proplists:get_value(test_dir, Config),
+
+    ok = py_context:exec(Ctx, iolist_to_binary(io_lib:format(
+        "import sys; sys.path.insert(0, '~s')", [TestDir]))),
+
+    %% Test that erlang.atom() creates equal atoms for same name
+    {ok, true} = py_context:call(Ctx, py_test_pid_send, atom_create_test, [], #{}),
+
+    py_context:stop(Ctx).
+
+%% @doc Test erlang.atom() creates unequal atoms for different names
+owngil_atom_create_different_test(Config) ->
+    {ok, Ctx} = py_context:start_link(1, owngil),
+    TestDir = proplists:get_value(test_dir, Config),
+
+    ok = py_context:exec(Ctx, iolist_to_binary(io_lib:format(
+        "import sys; sys.path.insert(0, '~s')", [TestDir]))),
+
+    %% Test that erlang.atom() creates different atoms for different names
+    {ok, true} = py_context:call(Ctx, py_test_pid_send, atom_create_different_test, [], #{}),
+
+    py_context:stop(Ctx).
+
+%% @doc Test erlang.atom() caching - same name returns same object
+owngil_atom_cache_test(Config) ->
+    {ok, Ctx} = py_context:start_link(1, owngil),
+    TestDir = proplists:get_value(test_dir, Config),
+
+    ok = py_context:exec(Ctx, iolist_to_binary(io_lib:format(
+        "import sys; sys.path.insert(0, '~s')", [TestDir]))),
+
+    %% Test atom caching - same object returned for same name
+    {ok, true} = py_context:call(Ctx, py_test_pid_send, atom_cache_test, [], #{}),
+
+    %% Also verify we can get the type name
+    {ok, TypeName} = py_context:call(Ctx, py_test_pid_send, atom_type_name, [], #{}),
+    ct:pal("Atom type name from erlang.atom(): ~p", [TypeName]),
+
+    py_context:stop(Ctx).
+
 %% @doc Ref type check and uniqueness in owngil context
 owngil_ref_roundtrip_test(Config) ->
     {ok, Ctx} = py_context:start_link(1, owngil),

test/py_test_pid_send.py

@@ -249,3 +249,36 @@ def pid_in_set(pid):
     """Test using PID in a set."""
     s = {pid}
     return pid in s
+
+
+# OWN_GIL test helpers for erlang.atom() creation
+
+def atom_create_test():
+    """Create atom using erlang.atom() in OWN_GIL and test equality."""
+    import erlang
+    a1 = erlang.atom('test_owngil_atom')
+    a2 = erlang.atom('test_owngil_atom')
+    return a1 == a2
+
+
+def atom_create_different_test():
+    """Test different atoms created with erlang.atom() are not equal."""
+    import erlang
+    a1 = erlang.atom('atom_x')
+    a2 = erlang.atom('atom_y')
+    return a1 != a2
+
+
+def atom_cache_test():
+    """Test atom caching - same name returns same object."""
+    import erlang
+    a1 = erlang.atom('cached_atom_owngil')
+    a2 = erlang.atom('cached_atom_owngil')
+    return a1 is a2  # Should be same object due to caching
+
+
+def atom_type_name():
+    """Get type name of atom created with erlang.atom()."""
+    import erlang
+    a = erlang.atom('type_check_atom')
+    return type(a).__name__