Nuitka-winsvc 2.4.11__cp311-cp311-win_amd64.whl → 2.5.6__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersComparisonNe.c

@@ -757,6 +757,8 @@ static PyObject *COMPARE_NE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand
         }
     }
 }
+#endif
+#if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
 PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
 
@@ -1392,6 +1394,8 @@ static bool COMPARE_NE_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2) {
         }
     }
 }
+#endif
+#if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
 nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
 
@@ -3585,6 +3589,8 @@ static PyObject *COMPARE_NE_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *ope
         }
     }
 }
+#endif
+#if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
 PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2) {
 
@@ -4220,6 +4226,8 @@ static bool COMPARE_NE_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2)
         }
     }
 }
+#endif
+#if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
 nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2) {
 
@@ -11673,7 +11681,6 @@ nuitka_bool RICH_COMPARE_NE_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operan
     return COMPARE_NE_NBOOL_LIST_LIST(operand1, operand2);
 }
 
-#if PYTHON_VERSION < 0x300
 static PyObject *COMPARE_NE_OBJECT_LONG_CLONG(PyObject *operand1, long operand2) {
     CHECK_OBJECT(operand1);
     assert(PyLong_CheckExact(operand1));
@@ -11705,7 +11712,8 @@ static PyObject *COMPARE_NE_OBJECT_LONG_CLONG(PyObject *operand1, long operand2)
         }
     }
 
-    Py_ssize_t operand2_size = operand2_is_negative == false ? operand2_digit_count : -operand2_digit_count;
+    NUITKA_MAY_BE_UNUSED Py_ssize_t operand2_size =
+        operand2_is_negative == false ? operand2_digit_count : -operand2_digit_count;
 
     bool r;
 
@@ -11727,6 +11735,7 @@ static PyObject *COMPARE_NE_OBJECT_LONG_CLONG(PyObject *operand1, long operand2)
     Py_INCREF_IMMORTAL(result);
     return result;
 }
+#if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
 PyObject *RICH_COMPARE_NE_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2) {
 
@@ -11734,7 +11743,6 @@ PyObject *RICH_COMPARE_NE_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2
 }
 #endif
 
-#if PYTHON_VERSION < 0x300
 static bool COMPARE_NE_CBOOL_LONG_CLONG(PyObject *operand1, long operand2) {
     CHECK_OBJECT(operand1);
     assert(PyLong_CheckExact(operand1));
@@ -11766,7 +11774,8 @@ static bool COMPARE_NE_CBOOL_LONG_CLONG(PyObject *operand1, long operand2) {
         }
     }
 
-    Py_ssize_t operand2_size = operand2_is_negative == false ? operand2_digit_count : -operand2_digit_count;
+    NUITKA_MAY_BE_UNUSED Py_ssize_t operand2_size =
+        operand2_is_negative == false ? operand2_digit_count : -operand2_digit_count;
 
     bool r;
 
@@ -11788,6 +11797,7 @@ static bool COMPARE_NE_CBOOL_LONG_CLONG(PyObject *operand1, long operand2) {
 
     return result;
 }
+#if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
 bool RICH_COMPARE_NE_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2) {
 
@@ -11810,6 +11820,8 @@ static PyObject *COMPARE_NE_OBJECT_INT_CLONG(PyObject *operand1, long operand2)
     Py_INCREF_IMMORTAL(result);
     return result;
 }
+#endif
+#if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
 PyObject *RICH_COMPARE_NE_OBJECT_INT_CLONG(PyObject *operand1, long operand2) {
 
@@ -11832,6 +11844,8 @@ static bool COMPARE_NE_CBOOL_INT_CLONG(PyObject *operand1, long operand2) {
 
     return result;
 }
+#endif
+#if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
 bool RICH_COMPARE_NE_CBOOL_INT_CLONG(PyObject *operand1, long operand2) {
 

nuitka/build/static_src/HelpersConsole.c

@@ -7,19 +7,29 @@
 #define _NUITKA_ATTACH_CONSOLE_WINDOW 1
 #endif
 
-#if defined(_WIN32) && defined(_NUITKA_ATTACH_CONSOLE_WINDOW)
+#if defined(_WIN32)
+#if defined(_NUITKA_ATTACH_CONSOLE_WINDOW)
 #include <io.h>
 
 // Attach to the parent console respecting redirection only, otherwise we cannot
 // even output traces.
-static bool needs_stdin_attaching, needs_stdout_attaching, needs_stderr_attaching;
+static bool needs_stdin_attaching = false;
+static bool needs_stdout_attaching = false;
+static bool needs_stderr_attaching = false;
 
-void inheritAttachedConsole(void) {
-    bool is_attachable = AttachConsole(ATTACH_PARENT_PROCESS);
+static bool is_attachable = false;
 
-    needs_stdin_attaching = is_attachable && fileno(stdin) < 0;
-    needs_stdout_attaching = is_attachable && fileno(stdout) < 0;
-    needs_stderr_attaching = is_attachable && fileno(stderr) < 0;
+void inheritAttachedConsole(void) {
+    is_attachable = AttachConsole(ATTACH_PARENT_PROCESS);
+
+    if (is_attachable) {
+        needs_stdin_attaching = fileno(stdin) < 0;
+        needs_stdout_attaching = fileno(stdout) < 0;
+#if !defined(NUITKA_FORCED_STDERR_PATH) && !defined(NUITKA_FORCED_STDERR_NONE_BOOL) &&                                 \
+    !defined(NUITKA_FORCED_STDERR_NULL_BOOL)
+        needs_stderr_attaching = fileno(stderr) < 0;
+#endif
+    }
 
     if (needs_stdin_attaching) {
         SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
@@ -72,12 +82,28 @@ void inheritAttachedConsole(void) {
         *stderr = *new_handle;
         SetStdHandle(STD_ERROR_HANDLE, win_handle);
     } else {
+#if !defined(NUITKA_FORCED_STDERR_PATH) && !defined(NUITKA_FORCED_STDERR_NONE_BOOL) &&                                 \
+    !defined(NUITKA_FORCED_STDERR_NULL_BOOL)
         setvbuf(stderr, NULL, _IONBF, 0);
         BOOL r = SetStdHandle(STD_ERROR_HANDLE, (HANDLE)_get_osfhandle(fileno(stderr)));
         assert(r);
+#endif
     }
 }
-
+#endif
+#if defined(_NUITKA_HIDE_CONSOLE_WINDOW)
+void hideConsoleIfSpawned(void) {
+    HWND hWnd = GetConsoleWindow();
+    DWORD consoleProcesses[2];
+    // detect if we were spawned from an existing cmdline window
+    DWORD numProcesses = GetConsoleProcessList(consoleProcesses, 2);
+    // if we have just one process that's us alone
+    if (hWnd && numProcesses <= 1) {
+        // then let's hide the console
+        ShowWindow(hWnd, SW_HIDE);
+    }
+}
+#endif
 #endif
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/static_src/HelpersConstantsBlob.c

@@ -325,6 +325,8 @@ static void initCaches(void) {
     Nuitka_Long_SmallValues = (PyObject **)_PyInterpreterState_GET()->small_ints;
 #elif PYTHON_VERSION >= 0x300
     for (long i = NUITKA_STATIC_SMALLINT_VALUE_MIN; i < NUITKA_STATIC_SMALLINT_VALUE_MAX; i++) {
+        // Have to use the original API here since out "Nuitka_PyLong_FromLong"
+        // would insist on using "Nuitka_Long_SmallValues" to produce it.
         PyObject *value = PyLong_FromLong(i);
         Nuitka_Long_SmallValues[NUITKA_TO_SMALL_VALUE_OFFSET(i)] = value;
     }
@@ -648,11 +650,11 @@ static unsigned char const *_unpackBlobConstant(PyThreadState *tstate, PyObject
     }
     case 'G':
     case 'g': {
-        PyObject *result = PyLong_FromLong(0);
+        PyObject *result = Nuitka_PyLong_FromLong(0);
 
         int size = (int)_unpackVariableLength(&data);
 
-        PyObject *shift = PyLong_FromLong(31);
+        PyObject *shift = Nuitka_PyLong_FromLong(31);
 
         for (int i = 0; i < size; i++) {
             result = PyNumber_InPlaceLshift(result, shift);

nuitka/build/static_src/HelpersDeepcopy.c

@@ -594,6 +594,7 @@ static PyObject *_DEEP_COPY_TUPLE_GUIDED(PyThreadState *tstate, PyObject *value,
     Py_ssize_t size = PyTuple_GET_SIZE(value);
 
     // We cannot have size 0, so this is safe.
+    assert(size > 0);
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {

nuitka/build/static_src/HelpersDictionaries.c

@@ -198,7 +198,7 @@ static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key
      * welcome. The check is inexact, as the unwrapping one is too.
      */
     if (PyTuple_Check(key) || key == Py_None) {
-        PyObject *tuple = PyTuple_Pack(1, key);
+        PyObject *tuple = MAKE_TUPLE1(tstate, key);
 
         SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_KeyError, tuple);
     } else {
@@ -751,7 +751,8 @@ typedef struct {
 #endif
 
 // Generic helper for various dictionary iterations, to be inlined.
-static inline PyObject *_MAKE_DICT_ITERATOR(PyDictObject *dict, PyTypeObject *type, bool is_iteritems) {
+static inline PyObject *_MAKE_DICT_ITERATOR(PyThreadState *tstate, PyDictObject *dict, PyTypeObject *type,
+                                            bool is_iteritems) {
     CHECK_OBJECT((PyObject *)dict);
     assert(PyDict_CheckExact((PyObject *)dict));
 
@@ -765,7 +766,7 @@ static inline PyObject *_MAKE_DICT_ITERATOR(PyDictObject *dict, PyTypeObject *ty
     di->len = dict->ma_used;
     if (is_iteritems) {
         // TODO: Have this as faster variants, we do these sometimes.
-        di->di_result = PyTuple_Pack(2, Py_None, Py_None);
+        di->di_result = MAKE_TUPLE2(tstate, Py_None, Py_None);
         CHECK_OBJECT(di->di_result);
     } else {
         di->di_result = NULL;
@@ -785,58 +786,54 @@ static inline PyObject *_MAKE_DICT_ITERATOR(PyDictObject *dict, PyTypeObject *ty
 #endif
 }
 
-PyObject *DICT_ITERITEMS(PyObject *dict) {
+PyObject *DICT_ITERITEMS(PyThreadState *tstate, PyObject *dict) {
 #if PYTHON_VERSION < 0x270
     static PyTypeObject *dictiteritems_type = NULL;
 
     if (unlikely(dictiteritems_type == NULL)) {
-        PyThreadState *tstate = PyThreadState_GET();
         dictiteritems_type =
             Py_TYPE(CALL_FUNCTION_NO_ARGS(tstate, PyObject_GetAttrString(const_dict_empty, "iteritems")));
     }
 
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, dictiteritems_type, true);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, dictiteritems_type, true);
 #elif PYTHON_VERSION < 0x300
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictIterItem_Type, true);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictIterItem_Type, true);
 #else
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictItems_Type, true);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictItems_Type, true);
 #endif
 }
 
-PyObject *DICT_ITERKEYS(PyObject *dict) {
+PyObject *DICT_ITERKEYS(PyThreadState *tstate, PyObject *dict) {
 #if PYTHON_VERSION < 0x270
     static PyTypeObject *dictiterkeys_type = NULL;
 
     if (unlikely(dictiterkeys_type == NULL)) {
-        PyThreadState *tstate = PyThreadState_GET();
         dictiterkeys_type =
             Py_TYPE(CALL_FUNCTION_NO_ARGS(tstate, PyObject_GetAttrString(const_dict_empty, "iterkeys")));
     }
 
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, dictiterkeys_type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, dictiterkeys_type, false);
 #elif PYTHON_VERSION < 0x300
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictIterKey_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictIterKey_Type, false);
 #else
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictKeys_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictKeys_Type, false);
 #endif
 }
 
-PyObject *DICT_ITERVALUES(PyObject *dict) {
+PyObject *DICT_ITERVALUES(PyThreadState *tstate, PyObject *dict) {
 #if PYTHON_VERSION < 0x270
     static PyTypeObject *dictitervalues_type = NULL;
 
     if (unlikely(dictitervalues_type == NULL)) {
-        PyThreadState *tstate = PyThreadState_GET();
-
         dictitervalues_type =
             Py_TYPE(CALL_FUNCTION_NO_ARGS(tstate, PyObject_GetAttrString(const_dict_empty, "itervalues")));
     }
 
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, dictitervalues_type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, dictitervalues_type, false);
 #elif PYTHON_VERSION < 0x300
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictIterValue_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictIterValue_Type, false);
 #else
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictValues_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictValues_Type, false);
 #endif
 }
 
@@ -899,6 +896,111 @@ PyObject *DICT_VIEWITEMS(PyObject *dict) {
 #endif
 }
 
+#if PYTHON_VERSION >= 0x300
+static PyDictObject *_Nuitka_AllocatePyDictObject(PyThreadState *tstate) {
+    PyDictObject *result_mp;
+
+#if NUITKA_DICT_HAS_FREELIST
+    // This is the CPython name, spell-checker: ignore numfree
+
+#if PYTHON_VERSION < 0x3d0
+    PyDictObject **items = tstate->interp->dict_state.free_list;
+    int *numfree = &tstate->interp->dict_state.numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_dict_freelist *state = &freelists->dicts;
+    PyDictObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
+
+    if (*numfree) {
+        (*numfree) -= 1;
+        result_mp = items[*numfree];
+
+        Nuitka_Py_NewReference((PyObject *)result_mp);
+
+        assert(PyDict_CheckExact((PyObject *)result_mp));
+        assert(result_mp != NULL);
+    } else
+#endif
+    {
+        result_mp = (PyDictObject *)Nuitka_GC_New(&PyDict_Type);
+    }
+
+    return result_mp;
+}
+#endif
+
+#if PYTHON_VERSION >= 0x360
+static PyDictKeysObject *_Nuitka_AllocatePyDictKeysObject(PyThreadState *tstate, Py_ssize_t keys_size) {
+    // CPython names, spell-checker: ignore numfree,dictkeys
+    PyDictKeysObject *dk;
+
+// TODO: Cannot always use cached objects. Need to also consider
+// "log2_size == PyDict_LOG_MINSIZE && unicode" as a criterion,
+// seems it can only be used for the smallest keys type.
+#if NUITKA_DICT_HAS_FREELIST && 0
+#if PYTHON_VERSION < 0x3d0
+    PyDictKeysObject **items = tstate->interp->dict_state.keys_free_list;
+    int *numfree = &tstate->interp->dict_state.keys_numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_dictkeys_freelist *state = &freelists->dictkeys;
+    PyDictKeysObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
+
+    if (*numfree) {
+        (*numfree) -= 1;
+        dk = items[*numfree];
+    } else
+#endif
+    {
+#if PYTHON_VERSION < 0x3d0
+        dk = (PyDictKeysObject *)NuitkaObject_Malloc(keys_size);
+#else
+        dk = (PyDictKeysObject *)NuitkaMem_Malloc(keys_size);
+#endif
+    }
+
+    return dk;
+}
+#endif
+
+#if PYTHON_VERSION >= 0x360 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT)
+
+// Usable fraction of keys.
+#define DK_USABLE_FRACTION(n) (((n) << 1) / 3)
+
+static Py_ssize_t _Nuitka_Py_PyDict_KeysSize(PyDictKeysObject *keys) {
+#if PYTHON_VERSION < 0x360
+    return sizeof(PyDictKeysObject) + (DK_SIZE(keys) - 1) * sizeof(PyDictKeyEntry);
+#elif PYTHON_VERSION < 0x370
+    return (sizeof(PyDictKeysObject) - Py_MEMBER_SIZE(PyDictKeysObject, dk_indices) + DK_IXSIZE(keys) * DK_SIZE(keys) +
+            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
+#elif PYTHON_VERSION < 0x3b0
+    return (sizeof(PyDictKeysObject) + DK_IXSIZE(keys) * DK_SIZE(keys) +
+            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
+#else
+    size_t entry_size = keys->dk_kind == DICT_KEYS_GENERAL ? sizeof(PyDictKeyEntry) : sizeof(PyDictUnicodeEntry);
+    return (sizeof(PyDictKeysObject) + ((size_t)1 << keys->dk_log2_index_bytes) +
+            DK_USABLE_FRACTION(DK_SIZE(keys)) * entry_size);
+#endif
+}
+#endif
+
+#if PYTHON_VERSION < 0x3b0
+typedef PyObject *PyDictValues;
+#endif
+
+#if PYTHON_VERSION < 0x360
+#define DK_ENTRIES_SIZE(keys) (keys->dk_size)
+#elif PYTHON_VERSION < 0x3b0
+#define DK_ENTRIES_SIZE(keys) DK_USABLE_FRACTION(DK_SIZE(keys))
+#else
+#define DK_ENTRIES_SIZE(keys) (keys->dk_nentries)
+#endif
+
 #include "HelpersDictionariesGenerated.c"
 
 void DICT_CLEAR(PyObject *dict) {
@@ -913,9 +1015,14 @@ void DICT_CLEAR(PyObject *dict) {
 #if PYTHON_VERSION >= 0x3b0
 static inline int Nuitka_py_get_index_from_order(PyDictObject *mp, Py_ssize_t i) {
     assert(mp->ma_used <= SHARED_KEYS_MAX_SIZE);
+#if PYTHON_VERSION < 0x3d0
     assert(i < (((char *)mp->ma_values)[-2]));
-
     return ((char *)mp->ma_values)[-3 - i];
+#else
+    assert(i < mp->ma_values->size);
+    uint8_t *array = get_insertion_order_array(mp->ma_values);
+    return array[i];
+#endif
 }
 #endif
 
@@ -947,7 +1054,14 @@ static inline Py_ssize_t Nuitka_Py_dictkeys_get_index(const PyDictKeysObject *ke
     return ix;
 }
 
-static inline Py_hash_t Nuitka_Py_unicode_get_hash(PyObject *o) { return _PyASCIIObject_CAST(o)->hash; }
+static inline Py_hash_t Nuitka_Py_unicode_get_hash(PyObject *o) {
+#if PYTHON_VERSION < 0x3d0
+    return _PyASCIIObject_CAST(o)->hash;
+#else
+    assert(PyUnicode_CheckExact(o));
+    return FT_ATOMIC_LOAD_SSIZE_RELAXED(_PyASCIIObject_CAST(o)->hash);
+#endif
+}
 
 // From CPython
 #define PERTURB_SHIFT 5
@@ -1002,9 +1116,9 @@ static Py_ssize_t Nuitka_Py_unicodekeys_lookup_generic(PyDictObject *mp, PyDictK
     NUITKA_CANNOT_GET_HERE("Nuitka_Py_unicodekeys_lookup_generic failed");
 }
 
-// TODO: Make use of this one in Nuitka_PyDictLookupStr
-static Py_ssize_t Nuitka_Py_unicodekeys_lookup_unicode(PyDictKeysObject *dk, PyObject *key, Py_hash_t hash) {
+Py_ssize_t Nuitka_Py_unicodekeys_lookup_unicode(PyDictKeysObject *dk, PyObject *key, Py_hash_t hash) {
     assert(PyUnicode_CheckExact(key));
+    assert(dk->dk_kind != DICT_KEYS_GENERAL);
 
     PyDictUnicodeEntry *ep0 = DK_UNICODE_ENTRIES(dk);
 
@@ -1095,7 +1209,6 @@ static Py_ssize_t Nuitka_Py_dictkeys_generic_lookup(PyDictObject *mp, PyDictKeys
         perturb >>= PERTURB_SHIFT;
         i = mask & (i * 5 + perturb + 1);
     }
-    Py_UNREACHABLE();
 }
 
 Py_ssize_t Nuitka_PyDictLookup(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject ***value_addr) {
@@ -1146,11 +1259,25 @@ restart:
     return ix;
 }
 
-// TODO: Take advantage of string key knowledge directly.
 Py_ssize_t Nuitka_PyDictLookupStr(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject ***value_addr) {
     assert(PyUnicode_CheckExact(key));
 
-    return Nuitka_PyDictLookup(mp, key, hash, value_addr);
+    PyDictKeysObject *dk = mp->ma_keys;
+    assert(dk->dk_kind != DICT_KEYS_GENERAL);
+
+    Py_ssize_t ix = Nuitka_Py_unicodekeys_lookup_unicode(dk, key, hash);
+
+    if (ix >= 0) {
+        if (dk->dk_kind == DICT_KEYS_SPLIT) {
+            *value_addr = &mp->ma_values->values[ix];
+        } else {
+            *value_addr = &DK_UNICODE_ENTRIES(dk)[ix].me_value;
+        }
+    } else {
+        *value_addr = NULL;
+    }
+
+    return ix;
 }
 
 #endif
@@ -1158,8 +1285,8 @@ Py_ssize_t Nuitka_PyDictLookupStr(PyDictObject *mp, PyObject *key, Py_hash_t has
 bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObject **value_ptr) {
     CHECK_OBJECT(dict);
     assert(PyDict_CheckExact(dict));
-    assert(key_ptr);
-    assert(value_ptr);
+    assert(key_ptr != NULL);
+    assert(value_ptr != NULL);
 
 #if PYTHON_VERSION < 0x300
     Py_ssize_t i = *pos;
@@ -1182,6 +1309,39 @@ bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObje
 
     return true;
 
+#elif PYTHON_VERSION < 0x360
+    PyDictObject *mp = (PyDictObject *)dict;
+    PyObject **dict_value_ptr;
+    Py_ssize_t offset;
+
+    Py_ssize_t i = *pos;
+    assert(i >= 0);
+
+    if (mp->ma_values) {
+        dict_value_ptr = &mp->ma_values[i];
+        offset = sizeof(PyObject *);
+    } else {
+        dict_value_ptr = &mp->ma_keys->dk_entries[i].me_value;
+        offset = sizeof(PyDictKeyEntry);
+    }
+
+    Py_ssize_t mask = DK_MASK(mp->ma_keys);
+
+    while ((i <= mask) && (*dict_value_ptr == NULL)) {
+        dict_value_ptr = (PyObject **)(((char *)dict_value_ptr) + offset);
+        i++;
+    }
+
+    if (i > mask) {
+        return false;
+    }
+
+    *key_ptr = mp->ma_keys->dk_entries[i].me_key;
+    *value_ptr = *dict_value_ptr;
+    *pos = i + 1;
+
+    return true;
+
 #elif PYTHON_VERSION < 0x3b0
     PyDictObject *mp = (PyDictObject *)dict;
     PyDictKeyEntry *entry;
@@ -1190,7 +1350,6 @@ bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObje
     Py_ssize_t i = *pos;
     assert(i >= 0);
 
-#ifndef PY_NOGIL
     if (mp->ma_values) {
         if (i >= mp->ma_used) {
             return false;
@@ -1200,15 +1359,9 @@ bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObje
         value = DK_VALUE(mp, i);
 
         assert(value != NULL);
-#else
-    if (false) {
-#endif
     } else {
-#if PYTHON_VERSION < 0x360
-        Py_ssize_t n = mp->ma_keys->dk_size;
-#else
         Py_ssize_t n = mp->ma_keys->dk_nentries;
-#endif
+
         if (i >= n) {
             return false;
         }
@@ -1357,6 +1510,10 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
     return result;
 }
 
+#if _NUITKA_MAINTAIN_DICT_VERSION_TAG
+uint64_t nuitka_dict_version_tag_counter = ((uint64_t)1) << 32;
+#endif
+
 #if NUITKA_DICT_HAS_FREELIST
 PyObject *MAKE_DICT_EMPTY(PyThreadState *tstate) {
     PyDictObject *empty_dict_mp = (PyDictObject *)const_dict_empty;
@@ -1372,6 +1529,8 @@ PyObject *MAKE_DICT_EMPTY(PyThreadState *tstate) {
     result_mp->ma_used = 0;
 #if PYTHON_VERSION >= 0x3c0
     result_mp->ma_version_tag = DICT_NEXT_VERSION(_PyInterpreterState_GET());
+#elif PYTHON_VERSION >= 0x360
+    result_mp->ma_version_tag = 1;
 #endif
 
     // Key reference needs to be counted on older Python