Nuitka-winsvc 2.2.2__cp311-cp311-win_amd64.whl → 2.3__cp311-cp311-win_amd64.whl

nuitka/code_generation/templates_c/HelperOperationComparisonUnicode.c.j2

@@ -1,6 +1,6 @@
 {#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file #}
 
-static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()}}_{{left.getHelperCodeName()}}_{{right.getHelperCodeName()}}({{left.getVariableDecl("operand1")}}, {{right.getVariableDecl("operand2")}}) {
+static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName()}}_{{left.getHelperCodeName()}}_{{right.getHelperCodeName()}}({{left.getVariableDecl("operand1")}}, {{right.getVariableDecl("operand2")}}) {
     {{left.getCheckValueCode("operand1")}}
     {{right.getCheckValueCode("operand2")}}
 
@@ -16,8 +16,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
 {% endif %}
 
         // Convert to target type.
-        {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r")}};
-        {{target.getTakeReferenceStatement("result")}}
+        {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r")}};
+        {{ target.getTakeReferenceStatement("result", immortal=True) }}
         return result;
     }
 
@@ -60,8 +60,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
         }
     }
 
-    {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
-    {{target.getTakeReferenceStatement("result")}}
+    {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
+    {{ target.getTakeReferenceStatement("result", immortal=True) }}
     return result;
 #else
     bool r;
@@ -77,8 +77,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
         r = (cmp == 0);
     }
 
-    {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
-    {{target.getTakeReferenceStatement("result")}}
+    {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
+    {{ target.getTakeReferenceStatement("result", immortal=True) }}
     return result;
 #endif
 {% else %}
@@ -91,9 +91,9 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
     return r;
 {% else %}
     // Convert to target type if necessary
-    {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r == Py_True")}};
-    Py_DECREF(r);
-    {{target.getTakeReferenceStatement("result")}}
+    {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r == Py_True")}};
+    Py_DECREF_IMMORTAL(r);
+    {{ target.getTakeReferenceStatement("result", immortal=True) }}
     return result;
 {% endif %}
 {% endif %}

nuitka/code_generation/templates_c/HelperOperationInplace.c.j2

@@ -23,7 +23,7 @@
             {{ goto_exit(props, "exit_inplace_result_object", "x") }}
         }
 
-        Py_DECREF(x);
+        Py_DECREF_IMMORTAL(x);
     }
 {% else %}
     // No inplace number slot {{ nb_inplace_slot }} available for this type.

nuitka/code_generation/templates_c/HelperSlotsBinary.c.j2

@@ -171,7 +171,7 @@
                     {{ goto_exit(props, exit_result_object, "x") }}
                 }
 
-                Py_DECREF(x);
+                Py_DECREF_IMMORTAL(x);
                 slot2 = NULL;
             }
         }
@@ -183,7 +183,7 @@
             {{ goto_exit(props, exit_result_object, "x") }}
         }
 
-        Py_DECREF(x);
+        Py_DECREF_IMMORTAL(x);
     }
 {% endif %}
 
@@ -195,7 +195,7 @@
             {{ goto_exit(props, exit_result_object, "x") }}
         }
 
-        Py_DECREF(x);
+        Py_DECREF_IMMORTAL(x);
     }
 {% endif %}
 

nuitka/code_generation/templates_c/HelperSlotsList.c.j2

@@ -9,7 +9,10 @@
     {# TODO: Could and should in-line and specialize this per slot too. #}
 {% if nb_slot == "nb_add" %}
 {% if left.type_name == "list" == right.type_name %}
-    PyObject *x = LIST_CONCAT({{ operand1 }}, {{ operand2 }});
+    // TODO: Have this more globally passed in
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *x = LIST_CONCAT(tstate, {{ operand1 }}, {{ operand2 }});
 {% else %}
     PyObject *x = {{ left.getSlotCallExpression("sq_concat", "PyList_Type.tp_as_sequence->sq_concat", operand1, operand2) }};
 {% endif %}

nuitka/code_generation/templates_c/HelperSlotsTuple.c.j2

@@ -9,7 +9,10 @@
     {# TODO: Could and should in-line and specialize this per slot too. #}
 {% if nb_slot == "nb_add" %}
 {% if left.type_name == "tuple" == right.type_name %}
-    PyObject *x = TUPLE_CONCAT({{ operand1 }}, {{ operand2 }});
+    // TODO: Have this more globally passed in
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *x = TUPLE_CONCAT(tstate, {{ operand1 }}, {{ operand2 }});
 {% else %}
     PyObject *x = {{ left.getSlotCallExpression("sq_concat", "PyTuple_Type.tp_as_sequence->sq_concat", operand1, operand2) }};
 {% endif %}

nuitka/finalizations/FinalizeMarkups.py

@@ -18,17 +18,9 @@ are in another context.
 """
 
 from nuitka import Tracing
-from nuitka.__past__ import unicode
-from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.PythonVersions import python_version
 from nuitka.tree.Operations import VisitorNoopMixin
 
-imported_names = OrderedSet()
-
-
-def getImportedNames():
-    return imported_names
-
 
 class FinalizeMarkups(VisitorNoopMixin):
     def onEnterNode(self, node):
@@ -66,16 +58,6 @@ class FinalizeMarkups(VisitorNoopMixin):
                 else:
                     search.markAsNeedsGeneratorReturnHandling(1)
 
-        if node.isExpressionBuiltinImport() and node.follow_attempted:
-            module_name = node.subnode_name
-
-            if module_name.isCompileTimeConstant():
-                imported_module_name = module_name.getCompileTimeConstant()
-
-                if type(imported_module_name) in (str, unicode):
-                    if imported_module_name:
-                        imported_names.add(imported_module_name)
-
         if node.isExpressionFunctionCreation():
             if (
                 not node.getParent().isExpressionFunctionCall()

nuitka/freezer/DependsExe.py

@@ -20,6 +20,7 @@ from nuitka.utils.FileOperations import (
     getFileContentByLine,
     getWindowsLongPathName,
     isFilenameBelowPath,
+    isFilesystemEncodable,
     putTextFileContents,
     withFileLock,
 )
@@ -160,10 +161,14 @@ def parseDependsExeOutput(filename):
 
 
 def detectDLLsWithDependencyWalker(binary_filename, source_dir, scan_dirs):
-    dwp_filename = os.path.join(source_dir, os.path.basename(binary_filename) + ".dwp")
-    output_filename = os.path.join(
-        source_dir, os.path.basename(binary_filename) + ".depends"
-    )
+    source_dir = getExternalUsePath(source_dir)
+    temp_base_name = os.path.basename(binary_filename)
+
+    if not isFilesystemEncodable(temp_base_name):
+        temp_base_name = "dependency_walker"
+
+    dwp_filename = os.path.join(source_dir, temp_base_name + ".dwp")
+    output_filename = os.path.join(source_dir, temp_base_name + ".depends")
 
     # User query should only happen once if at all.
     with withFileLock(

nuitka/freezer/DllDependenciesMacOS.py

@@ -175,7 +175,7 @@ def _resolveBinaryPathDLLsMacOS(
                     resolved_path = os.path.normpath(os.path.join(rpath, path[7:]))
                     break
             else:
-                # These have become virtual in later macOS.
+                # These have become virtual in later macOS, spell-checker: ignore libz
                 if library_name in ("libc++.1.dylib", "libz.1.dylib"):
                     continue
 

nuitka/freezer/DllDependenciesWin32.py

@@ -100,7 +100,7 @@ def _getScanDirectories(package_name, original_dir):
     if cache_key in _scan_dir_cache:
         return _scan_dir_cache[cache_key]
 
-    scan_dirs = [getSystemPrefixPath()]
+    scan_dirs = [os.path.dirname(sys.executable), getSystemPrefixPath()]
 
     if package_name is not None:
         scan_dirs.extend(getPackageSpecificDLLDirectories(package_name))

nuitka/freezer/ImportDetection.py

@@ -210,6 +210,7 @@ def _detectEarlyImports():
         "base64_codec",
         "hex_codec",
         "rot_13",
+        "punycode",
     ):
         if non_locale_encoding in encoding_names:
             encoding_names.remove(non_locale_encoding)

nuitka/freezer/IncludedDataFiles.py

@@ -227,13 +227,22 @@ def makeIncludedDataDirectory(
     ignore_suffixes=(),
     only_suffixes=(),
     normalize=True,
+    raw=False,
 ):
     assert isRelativePath(dest_path), dest_path
     assert os.path.isdir(source_path), source_path
 
-    ignore_dirs = tuple(ignore_dirs) + default_ignored_dirs
-    ignore_filenames = tuple(ignore_filenames) + default_ignored_filenames
-    ignore_suffixes = tuple(ignore_suffixes) + default_ignored_suffixes
+    ignore_dirs = tuple(ignore_dirs)
+    if not raw:
+        ignore_dirs += default_ignored_dirs
+
+    ignore_filenames = tuple(ignore_filenames)
+    if not raw:
+        ignore_filenames += default_ignored_filenames
+
+    ignore_suffixes = tuple(ignore_suffixes)
+    if not raw:
+        ignore_suffixes += default_ignored_suffixes
 
     for filename in getFileList(
         source_path,
@@ -255,7 +264,7 @@ def makeIncludedDataDirectory(
             tags=tags,
         )
 
-        included_datafile.tags.add("data-dir-contents")
+        included_datafile.tags.add("raw-dir-contents" if raw else "data-dir-contents")
 
         yield included_datafile
 

nuitka/freezer/Onefile.py

@@ -61,7 +61,6 @@ def _runOnefileScons(onefile_compression, onefile_archive):
     Plugins.writeExtraCodeFiles(onefile=True)
 
     options = {
-        "result_name": OutputDirectories.getResultBasePath(onefile=True),
         "result_exe": OutputDirectories.getResultFullpath(onefile=True),
         "source_dir": source_dir,
         "debug_mode": asBoolStr(Options.is_debug),

nuitka/freezer/Standalone.py

@@ -251,7 +251,9 @@ def _detectUsedDLLs(standalone_entry_point, source_dir):
             update_cache=not shallNotStoreDependsExeCachedResults(),
         )
     except NuitkaForbiddenDLLEncounter:
-        inclusion_logger.info("Not including forbidden DLL '%s'." % binary_filename)
+        inclusion_logger.info(
+            "Not including due to forbidden DLL '%s'." % binary_filename
+        )
     else:
         # Plugins generally decide if they allow dependencies from the outside
         # based on the package name.

nuitka/importing/ImportCache.py

@@ -14,6 +14,7 @@ not start anew, but reuse what we already found out about it.
 import os
 
 from nuitka.plugins.Plugins import Plugins
+from nuitka.utils.Importing import hasPackageDirFilename
 
 imported_modules = {}
 imported_by_name = {}
@@ -22,7 +23,7 @@ imported_by_name = {}
 def addImportedModule(imported_module):
     module_filename = os.path.abspath(imported_module.getFilename())
 
-    if os.path.basename(module_filename) == "__init__.py":
+    if hasPackageDirFilename(module_filename):
         module_filename = os.path.dirname(module_filename)
 
     key = (module_filename, imported_module.getFullName())
@@ -55,7 +56,7 @@ def getImportedModuleByNameAndPath(full_name, module_filename):
     # For caching we use absolute paths only.
     module_filename = os.path.abspath(module_filename)
 
-    if os.path.basename(module_filename) == "__init__.py":
+    if hasPackageDirFilename(module_filename):
         module_filename = os.path.dirname(module_filename)
 
     # KeyError is valid result.

nuitka/importing/Importing.py

@@ -41,6 +41,7 @@ from nuitka.utils.Hashing import getFileContentsHash
 from nuitka.utils.Importing import (
     builtin_module_names,
     getModuleFilenameSuffixes,
+    getPackageDirFilename,
     getSharedLibrarySuffixes,
     isBuiltinModuleName,
 )
@@ -228,6 +229,16 @@ def getModuleNameAndKindFromFilename(module_filename):
             )
 
     if os.path.isdir(module_filename):
+        package_filename = getPackageDirFilename(module_filename)
+
+        if package_filename is not None:
+            for suffix in getSharedLibrarySuffixes():
+                if package_filename.endswith(suffix):
+                    return (
+                        ModuleName(os.path.basename(module_filename)),
+                        "extension",
+                    )
+
         return ModuleName(os.path.basename(module_filename)), "py"
 
     return None, None
@@ -507,9 +518,6 @@ def _findModuleInPath2(package_name, module_name, search_path):
             found = False
 
             for suffix, module_type in getModuleFilenameSuffixes():
-                if module_type == "C_EXTENSION":
-                    continue
-
                 package_file_name = "__init__" + suffix
 
                 file_path = os.path.join(package_directory, package_file_name)
@@ -1016,6 +1024,11 @@ _stdlib_module_raises = {
     "zlib": False,
     "_ssl": True,
     "_xxinterpchannels": False,
+    # TODO: 3.13 clarify if this is actually true
+    "_interpchannels": False,
+    "_interpreters": False,
+    "_interpqueues": False,
+    "_sysconfig": False,
 }
 
 

nuitka/importing/StandardLibrary.py

@@ -18,6 +18,7 @@ from nuitka.PythonVersions import python_version
 from nuitka.utils.FileOperations import getFileContents, isFilenameBelowPath
 from nuitka.utils.ModuleNames import ModuleName
 from nuitka.utils.Utils import (
+    isMacOS,
     isNetBSD,
     isPosixWindows,
     isWin32OrPosixWindows,
@@ -175,6 +176,9 @@ def scanStandardLibraryPath(stdlib_dir):
             if "ensurepip" in dirs:
                 dirs.remove("ensurepip")
 
+            if "_ios_support.py" in filenames and not isMacOS():
+                filenames.remove("_ios_support.py")
+
             # Ignore "lib-dynload" and "lib-tk" and alike.
             dirs[:] = [
                 dirname

nuitka/nodes/ChildrenHavingMixins.py

@@ -13853,6 +13853,7 @@ class ChildHavingPathMixin(object):
     #   ExpressionOsPathExists
     #   ExpressionOsPathIsdir
     #   ExpressionOsPathIsfile
+    #   ExpressionOsPathNormpath
 
     def __init__(
         self,
@@ -13939,6 +13940,7 @@ ChildrenExpressionOsPathAbspathMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathExistsMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathIsdirMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathIsfileMixin = ChildHavingPathMixin
+ChildrenExpressionOsPathNormpathMixin = ChildHavingPathMixin
 
 
 class ChildHavingPathOptionalMixin(object):

nuitka/nodes/ExpressionBasesGenerated.py

@@ -206,6 +206,7 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 
     # This is generated for use in
     #   ExpressionBuiltinMakeExceptionImportError
+    #   ExpressionBuiltinMakeExceptionModuleNotFoundError
 
     def __init__(self, args, name, path, source_ref):
         assert type(args) is tuple
@@ -390,6 +391,9 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 ExpressionBuiltinMakeExceptionImportErrorBase = (
     ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin
 )
+ExpressionBuiltinMakeExceptionModuleNotFoundErrorBase = (
+    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin
+)
 
 
 class ChildrenHavingCallableArgSentinelFinalMixin(ExpressionBase):

nuitka/nodes/HardImportNodesGenerated.py

@@ -63,6 +63,7 @@ from nuitka.specs.HardImportSpecs import (
     os_path_isabs_spec,
     os_path_isdir_spec,
     os_path_isfile_spec,
+    os_path_normpath_spec,
     os_uname_spec,
     pkg_resources_get_distribution_spec,
     pkg_resources_iter_entry_points_spec,
@@ -2489,6 +2490,88 @@ class ExpressionOsPathIsfileCallBase(ChildHavingPathMixin, ExpressionBase):
         return True
 
 
+class ExpressionOsPathNormpathRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.path.normpath"""
+
+    kind = "EXPRESSION_OS_PATH_NORMPATH_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name=os.path.__name__,
+            import_name="normpath",
+            module_guaranteed=True,
+            source_ref=source_ref,
+        )
+
+    def computeExpressionCall(self, call_node, call_args, call_kw, trace_collection):
+        # Anything may happen on call trace before this. On next pass, if
+        # replaced, we might be better but not now.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        from .OsSysNodes import ExpressionOsPathNormpathCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsPathNormpathCall,
+            builtin_spec=os_path_normpath_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.path.normpath' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsPathNormpathRef] = os_path_normpath_spec
+
+
+class ExpressionOsPathNormpathCallBase(ChildHavingPathMixin, ExpressionBase):
+    """Base class for OsPathNormpathCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = ("path",)
+
+    __slots__ = ("attempted",)
+
+    spec = os_path_normpath_spec
+
+    def __init__(self, path, source_ref):
+
+        ChildHavingPathMixin.__init__(
+            self,
+            path=path,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not os_path_normpath_spec.isCompileTimeComputable(
+            (self.subnode_path,)
+        ):
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return self, None, None
+
+        try:
+            return self.replaceWithCompileTimeValue(trace_collection)
+        finally:
+            self.attempted = True
+
+    @abstractmethod
+    def replaceWithCompileTimeValue(self, trace_collection):
+        pass
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return True
+
+
 class ExpressionOsUnameRef(ExpressionImportModuleNameHardExistsSpecificBase):
     """Function reference os.uname"""
 

nuitka/nodes/ModuleNodes.py

@@ -20,6 +20,7 @@ from nuitka.PythonVersions import python_version
 from nuitka.SourceCodeReferences import fromFilename
 from nuitka.tree.SourceHandling import parsePyIFile, readSourceCodeFromFilename
 from nuitka.utils.CStrings import encodePythonIdentifierToC
+from nuitka.utils.Importing import getSharedLibrarySuffix
 from nuitka.utils.ModuleNames import ModuleName
 
 from .ChildrenHavingMixins import (
@@ -971,13 +972,14 @@ class PythonMainModule(CompiledPythonModule):
 class PythonExtensionModule(PythonModuleBase):
     kind = "PYTHON_EXTENSION_MODULE"
 
-    __slots__ = ("used_modules", "technical")
+    __slots__ = ("used_modules", "module_filename", "technical")
 
     avoid_duplicates = set()
 
     def __init__(
         self,
         module_name,
+        module_filename,
         reason,
         technical,
         source_ref,
@@ -1005,11 +1007,17 @@ class PythonExtensionModule(PythonModuleBase):
 
         self.used_modules = None
 
+        if os.path.isdir(module_filename):
+            module_filename = os.path.join(
+                module_filename, "__init__" + getSharedLibrarySuffix(preferred=False)
+            )
+        self.module_filename = module_filename
+
     def finalize(self):
         del self.used_modules
 
     def getFilename(self):
-        return self.source_ref.getFilename()
+        return self.module_filename
 
     @staticmethod
     def startTraversal():

nuitka/nodes/OsSysNodes.py

@@ -112,6 +112,22 @@ class ExpressionOsPathAbspathCall(ExpressionOsPathAbspathCallBase):
         return self, None, None
 
 
+class ExpressionOsPathNormpathCall(ExpressionOsPathAbspathCallBase):
+    kind = "EXPRESSION_OS_PATH_NORMPATH_CALL"
+
+    def replaceWithCompileTimeValue(self, trace_collection):
+        result = makeConstantRefNode(
+            constant=os.path.normpath(self.subnode_path.getCompileTimeConstant()),
+            source_ref=self.source_ref,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Compile time resolved 'os.path.normpath' call.",
+        )
+
+
 class ExpressionOsPathIsabsCall(ExpressionOsPathIsabsCallBase):
     kind = "EXPRESSION_OS_PATH_ISABS_CALL"
 

nuitka/nodes/SubscriptNodes.py

@@ -118,13 +118,13 @@ def hasSubscript(value, subscript):
         return True
 
 
-class ExpressionSubscriptCheck(
+class ExpressionMatchSubscriptCheck(
     ExpressionBoolShapeExactMixin,
     SideEffectsFromChildrenMixin,
     ChildrenHavingExpressionSubscriptMixin,
     ExpressionBase,
 ):
-    kind = "EXPRESSION_SUBSCRIPT_CHECK"
+    kind = "EXPRESSION_MATCH_SUBSCRIPT_CHECK"
 
     named_children = ("expression", "subscript")
 
@@ -153,7 +153,7 @@ class ExpressionSubscriptCheck(
                 computation=lambda: hasSubscript(
                     source.getCompileTimeConstant(), subscript.getCompileTimeConstant()
                 ),
-                description="Subscript check has been pre-computed.",
+                description="Subscript match check has been pre-computed.",
             )
 
             # If source has side effects, they must be evaluated.

nuitka/plugins/PluginBase.py

@@ -895,6 +895,7 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
         ignore_suffixes=(),
         only_suffixes=(),
         normalize=True,
+        raw=False,
     ):
         return makeIncludedDataDirectory(
             source_path=source_path,
@@ -907,6 +908,7 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
             ignore_suffixes=ignore_suffixes,
             only_suffixes=only_suffixes,
             normalize=normalize,
+            raw=raw,
         )
 
     def makeIncludedEmptyDirectory(self, dest_path, reason, tags):

nuitka/plugins/standard/DataFilesPlugin.py

@@ -120,7 +120,7 @@ class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
         if dirs is not None:
             if type(dirs) is not list or not dirs:
                 self.sysexit(
-                    "Error, requiring list below 'empty_dirs_structure' entry for '%s' entry."
+                    "Error, requiring list below 'dirs' entry for '%s' entry."
                     % module_name
                 )
 
@@ -136,6 +136,27 @@ class NuitkaPluginDataFileCollector(NuitkaYamlPluginBase):
                         tags="config",
                     )
 
+        raw_dirs = data_file_config.get("raw_dirs")
+        if raw_dirs is not None:
+            if type(raw_dirs) is not list or not raw_dirs:
+                self.sysexit(
+                    "Error, requiring list below 'raw_dirs' entry for '%s' entry."
+                    % module_name
+                )
+
+            for raw_dir in raw_dirs:
+                source_path = os.path.join(module_folder, raw_dir)
+
+                if os.path.isdir(source_path):
+                    yield self.makeIncludedDataDirectory(
+                        source_path=source_path,
+                        dest_path=os.path.join(target_dir, raw_dir),
+                        reason="package raw directory '%s' for %r"
+                        % (raw_dir, module_name.asString()),
+                        tags="config",
+                        raw=True,
+                    )
+
         include_pyi_file = data_file_config.get("include-pyi-file")
 
         if include_pyi_file == "yes":

nuitka/plugins/standard/DillPlugin/DillPlugin.c

@@ -11,12 +11,12 @@ void registerDillPluginTables(PyThreadState *tstate, char const *module_name, Py
     if (function_tables == NULL) {
         CLEAR_ERROR_OCCURRED(tstate);
 
-        function_tables = MAKE_DICT_EMPTY();
+        function_tables = MAKE_DICT_EMPTY(tstate);
         PyObject_SetAttrString((PyObject *)builtin_module, "compiled_function_tables", function_tables);
     }
 
-    PyObject *funcs =
-        MAKE_TUPLE2_0(PyCFunction_New(reduce_compiled_function, NULL), PyCFunction_New(create_compiled_function, NULL));
+    PyObject *funcs = MAKE_TUPLE2_0(tstate, PyCFunction_New(reduce_compiled_function, NULL),
+                                    PyCFunction_New(create_compiled_function, NULL));
 
     PyDict_SetItemString(function_tables, module_name, funcs);
 }