Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/nodes/HardImportNodesGenerated.py

@@ -1,33 +1,34 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 # We are not avoiding these in generated code at all
-# pylint: disable=I0021,too-many-lines
-# pylint: disable=I0021,line-too-long
-# pylint: disable=I0021,too-many-instance-attributes
-# pylint: disable=I0021,too-many-return-statements
+# pylint: disable=I0021,line-too-long,too-many-instance-attributes,too-many-lines
+# pylint: disable=I0021,too-many-arguments,too-many-return-statements,too-many-statements
 
 
 """Hard import nodes
 
 WARNING, this code is GENERATED. Modify the template HardImportReferenceNode.py.j2 instead!
 
-spell-checker: ignore append capitalize casefold center clear copy count decode encode endswith expandtabs extend find format formatmap fromkeys get haskey index insert isalnum isalpha isascii isdecimal isdigit isidentifier islower isnumeric isprintable isspace istitle isupper items iteritems iterkeys itervalues join keys ljust lower lstrip maketrans partition pop popitem prepare remove replace reverse rfind rindex rjust rpartition rsplit rstrip setdefault sort split splitlines startswith strip swapcase title translate update upper values viewitems viewkeys viewvalues zfill
-spell-checker: ignore args chars count default delete encoding end errors fillchar index item iterable keepends key kwargs maxsplit new old pairs prefix sep start stop sub suffix table tabsize value width
+spell-checker: ignore __prepare__ append args autograph capitalize casefold center chars
+spell-checker: ignore clear copy count decode default delete dist distribution_name encode
+spell-checker: ignore encoding end endswith errors exit_code expandtabs
+spell-checker: ignore experimental_attributes experimental_autograph_options
+spell-checker: ignore experimental_compile experimental_follow_type_hints
+spell-checker: ignore experimental_implements experimental_relax_shapes extend fillchar
+spell-checker: ignore find format format_map formatmap fromkeys func get group handle
+spell-checker: ignore has_key haskey index input_signature insert isalnum isalpha isascii
+spell-checker: ignore isdecimal isdigit isidentifier islower isnumeric isprintable isspace
+spell-checker: ignore istitle isupper item items iterable iteritems iterkeys itervalues
+spell-checker: ignore jit_compile join keepends key keys kwargs ljust lower lstrip
+spell-checker: ignore maketrans maxsplit mode name new old p package
+spell-checker: ignore package_or_requirement pairs partition path pop popitem prefix
+spell-checker: ignore prepare reduce_retracing remove replace resource resource_name
+spell-checker: ignore reverse rfind rindex rjust rpartition rsplit rstrip s sep setdefault
+spell-checker: ignore sort split splitlines start startswith stop strip sub suffix
+spell-checker: ignore swapcase table tabsize title translate update upper use_errno
+spell-checker: ignore use_last_error value values viewitems viewkeys viewvalues width
+spell-checker: ignore winmode zfill
 """
 import os
 from abc import abstractmethod
@@ -54,12 +55,16 @@ from nuitka.specs.HardImportSpecs import (
     importlib_resources_read_binary_spec,
     importlib_resources_read_text_spec,
     os_listdir_spec,
+    os_lstat_spec,
     os_path_abspath_spec,
     os_path_basename_spec,
+    os_path_dirname_spec,
     os_path_exists_spec,
     os_path_isabs_spec,
     os_path_isdir_spec,
     os_path_isfile_spec,
+    os_path_normpath_spec,
+    os_stat_spec,
     os_uname_spec,
     pkg_resources_get_distribution_spec,
     pkg_resources_iter_entry_points_spec,
@@ -67,11 +72,14 @@ from nuitka.specs.HardImportSpecs import (
     pkg_resources_resource_stream_spec,
     pkg_resources_resource_string_spec,
     pkgutil_get_data_spec,
+    sys_exit_spec,
+    tensorflow_function_spec,
 )
 
 from .ChildrenHavingMixins import (
     ChildHavingDistMixin,
     ChildHavingDistributionNameMixin,
+    ChildHavingExitCodeOptionalMixin,
     ChildHavingPackageMixin,
     ChildHavingParamsTupleMixin,
     ChildHavingPathMixin,
@@ -79,12 +87,15 @@ from .ChildrenHavingMixins import (
     ChildHavingPMixin,
     ChildHavingRequirementsTupleMixin,
     ChildHavingSMixin,
+    ChildrenHavingFuncOptionalInputSignatureOptionalAutographOptionalJitCompileOptionalReduceRetracingOptionalExperimentalImplementsOptionalExperimentalAutographOptionsOptionalExperimentalAttributesOptionalExperimentalRelaxShapesOptionalExperimentalCompileOptionalExperimentalFollowTypeHintsOptionalMixin,
     ChildrenHavingGroupNameOptionalMixin,
-    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalMixin,
-    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalWinmodeOptionalMixin,
+    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalMixin,
+    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalWinmodeOptionalMixin,
     ChildrenHavingPackageOrRequirementResourceNameMixin,
     ChildrenHavingPackageResourceEncodingOptionalErrorsOptionalMixin,
     ChildrenHavingPackageResourceMixin,
+    ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin,
+    ChildrenHavingPathOptionalDirFdOptionalMixin,
 )
 from .ExpressionBases import ExpressionBase
 from .ExpressionShapeMixins import (
@@ -152,7 +163,7 @@ hard_import_node_classes[ExpressionCtypesCdllRef] = ctypes_cdll_since_38_spec
 
 
 class ExpressionCtypesCdllSince38CallBase(
-    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalWinmodeOptionalMixin,
+    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalWinmodeOptionalMixin,
     ExpressionBase,
 ):
     """Base class for CtypesCdllCall
@@ -167,7 +178,7 @@ class ExpressionCtypesCdllSince38CallBase(
         "mode|optional",
         "handle|optional",
         "use_errno|optional",
-        "use_lasterror|optional",
+        "use_last_error|optional",
         "winmode|optional",
     )
 
@@ -176,22 +187,22 @@ class ExpressionCtypesCdllSince38CallBase(
     spec = ctypes_cdll_since_38_spec
 
     def __init__(
-        self, name, mode, handle, use_errno, use_lasterror, winmode, source_ref
+        self, name, mode, handle, use_errno, use_last_error, winmode, source_ref
     ):
-        ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalWinmodeOptionalMixin.__init__(
+
+        ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalWinmodeOptionalMixin.__init__(
             self,
             name=name,
             mode=mode,
             handle=handle,
             use_errno=use_errno,
-            use_lasterror=use_lasterror,
+            use_last_error=use_last_error,
             winmode=winmode,
         )
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not ctypes_cdll_since_38_spec.isCompileTimeComputable(
@@ -200,7 +211,7 @@ class ExpressionCtypesCdllSince38CallBase(
                 self.subnode_mode,
                 self.subnode_handle,
                 self.subnode_use_errno,
-                self.subnode_use_lasterror,
+                self.subnode_use_last_error,
                 self.subnode_winmode,
             )
         ):
@@ -223,7 +234,7 @@ class ExpressionCtypesCdllSince38CallBase(
 
 
 class ExpressionCtypesCdllBefore38CallBase(
-    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalMixin,
+    ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalMixin,
     ExpressionBase,
 ):
     """Base class for CtypesCdllCall
@@ -238,27 +249,27 @@ class ExpressionCtypesCdllBefore38CallBase(
         "mode|optional",
         "handle|optional",
         "use_errno|optional",
-        "use_lasterror|optional",
+        "use_last_error|optional",
     )
 
     __slots__ = ("attempted",)
 
     spec = ctypes_cdll_before_38_spec
 
-    def __init__(self, name, mode, handle, use_errno, use_lasterror, source_ref):
-        ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalMixin.__init__(
+    def __init__(self, name, mode, handle, use_errno, use_last_error, source_ref):
+
+        ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalMixin.__init__(
             self,
             name=name,
             mode=mode,
             handle=handle,
             use_errno=use_errno,
-            use_lasterror=use_lasterror,
+            use_last_error=use_last_error,
         )
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not ctypes_cdll_before_38_spec.isCompileTimeComputable(
@@ -267,7 +278,7 @@ class ExpressionCtypesCdllBefore38CallBase(
                 self.subnode_mode,
                 self.subnode_handle,
                 self.subnode_use_errno,
-                self.subnode_use_lasterror,
+                self.subnode_use_last_error,
             )
         ):
             trace_collection.onExceptionRaiseExit(BaseException)
@@ -326,9 +337,9 @@ class ExpressionImportlibMetadataBackportDistributionRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataBackportDistributionRef
-] = importlib_metadata_backport_distribution_spec
+hard_import_node_classes[ExpressionImportlibMetadataBackportDistributionRef] = (
+    importlib_metadata_backport_distribution_spec
+)
 
 
 class ExpressionImportlibMetadataBackportDistributionCallBase(
@@ -346,6 +357,7 @@ class ExpressionImportlibMetadataBackportDistributionCallBase(
     spec = importlib_metadata_backport_distribution_spec
 
     def __init__(self, distribution_name, source_ref):
+
         ChildHavingDistributionNameMixin.__init__(
             self,
             distribution_name=distribution_name,
@@ -419,9 +431,9 @@ class ExpressionImportlibMetadataBackportEntryPointsRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataBackportEntryPointsRef
-] = importlib_metadata_backport_entry_points_spec
+hard_import_node_classes[ExpressionImportlibMetadataBackportEntryPointsRef] = (
+    importlib_metadata_backport_entry_points_spec
+)
 
 
 class ExpressionImportlibMetadataBackportEntryPointsCallBase(
@@ -439,6 +451,7 @@ class ExpressionImportlibMetadataBackportEntryPointsCallBase(
     spec = importlib_metadata_backport_entry_points_spec
 
     def __init__(self, params, source_ref):
+
         ChildHavingParamsTupleMixin.__init__(
             self,
             params=params,
@@ -512,9 +525,9 @@ class ExpressionImportlibMetadataBackportMetadataRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataBackportMetadataRef
-] = importlib_metadata_backport_metadata_spec
+hard_import_node_classes[ExpressionImportlibMetadataBackportMetadataRef] = (
+    importlib_metadata_backport_metadata_spec
+)
 
 
 class ExpressionImportlibMetadataBackportMetadataCallBase(
@@ -532,6 +545,7 @@ class ExpressionImportlibMetadataBackportMetadataCallBase(
     spec = importlib_metadata_backport_metadata_spec
 
     def __init__(self, distribution_name, source_ref):
+
         ChildHavingDistributionNameMixin.__init__(
             self,
             distribution_name=distribution_name,
@@ -605,9 +619,9 @@ class ExpressionImportlibMetadataBackportVersionRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataBackportVersionRef
-] = importlib_metadata_backport_version_spec
+hard_import_node_classes[ExpressionImportlibMetadataBackportVersionRef] = (
+    importlib_metadata_backport_version_spec
+)
 
 
 class ExpressionImportlibMetadataBackportVersionCallBase(
@@ -625,6 +639,7 @@ class ExpressionImportlibMetadataBackportVersionCallBase(
     spec = importlib_metadata_backport_version_spec
 
     def __init__(self, distribution_name, source_ref):
+
         ChildHavingDistributionNameMixin.__init__(
             self,
             distribution_name=distribution_name,
@@ -698,9 +713,9 @@ class ExpressionImportlibMetadataDistributionRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataDistributionRef
-] = importlib_metadata_distribution_spec
+hard_import_node_classes[ExpressionImportlibMetadataDistributionRef] = (
+    importlib_metadata_distribution_spec
+)
 
 
 class ExpressionImportlibMetadataDistributionCallBase(
@@ -718,6 +733,7 @@ class ExpressionImportlibMetadataDistributionCallBase(
     spec = importlib_metadata_distribution_spec
 
     def __init__(self, distribution_name, source_ref):
+
         ChildHavingDistributionNameMixin.__init__(
             self,
             distribution_name=distribution_name,
@@ -725,8 +741,7 @@ class ExpressionImportlibMetadataDistributionCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if (
@@ -809,9 +824,9 @@ class ExpressionImportlibMetadataEntryPointsRef(
             )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataEntryPointsRef
-] = importlib_metadata_entry_points_since_310_spec
+hard_import_node_classes[ExpressionImportlibMetadataEntryPointsRef] = (
+    importlib_metadata_entry_points_since_310_spec
+)
 
 
 class ExpressionImportlibMetadataEntryPointsSince310CallBase(
@@ -831,6 +846,7 @@ class ExpressionImportlibMetadataEntryPointsSince310CallBase(
     spec = importlib_metadata_entry_points_since_310_spec
 
     def __init__(self, params, source_ref):
+
         ChildHavingParamsTupleMixin.__init__(
             self,
             params=params,
@@ -838,8 +854,7 @@ class ExpressionImportlibMetadataEntryPointsSince310CallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if (
@@ -881,10 +896,10 @@ class ExpressionImportlibMetadataEntryPointsBefore310CallBase(
     spec = importlib_metadata_entry_points_before_310_spec
 
     def __init__(self, source_ref):
+
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def finalize(self):
         del self.parent
@@ -947,9 +962,9 @@ class ExpressionImportlibMetadataMetadataRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataMetadataRef
-] = importlib_metadata_metadata_spec
+hard_import_node_classes[ExpressionImportlibMetadataMetadataRef] = (
+    importlib_metadata_metadata_spec
+)
 
 
 class ExpressionImportlibMetadataMetadataCallBase(
@@ -967,6 +982,7 @@ class ExpressionImportlibMetadataMetadataCallBase(
     spec = importlib_metadata_metadata_spec
 
     def __init__(self, distribution_name, source_ref):
+
         ChildHavingDistributionNameMixin.__init__(
             self,
             distribution_name=distribution_name,
@@ -974,8 +990,7 @@ class ExpressionImportlibMetadataMetadataCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if (
@@ -1040,9 +1055,9 @@ class ExpressionImportlibMetadataVersionRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibMetadataVersionRef
-] = importlib_metadata_version_spec
+hard_import_node_classes[ExpressionImportlibMetadataVersionRef] = (
+    importlib_metadata_version_spec
+)
 
 
 class ExpressionImportlibMetadataVersionCallBase(
@@ -1060,6 +1075,7 @@ class ExpressionImportlibMetadataVersionCallBase(
     spec = importlib_metadata_version_spec
 
     def __init__(self, distribution_name, source_ref):
+
         ChildHavingDistributionNameMixin.__init__(
             self,
             distribution_name=distribution_name,
@@ -1067,8 +1083,7 @@ class ExpressionImportlibMetadataVersionCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if (
@@ -1133,9 +1148,9 @@ class ExpressionImportlibResourcesBackportFilesRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibResourcesBackportFilesRef
-] = importlib_resources_backport_files_spec
+hard_import_node_classes[ExpressionImportlibResourcesBackportFilesRef] = (
+    importlib_resources_backport_files_spec
+)
 
 
 class ExpressionImportlibResourcesBackportFilesCallBase(
@@ -1153,6 +1168,7 @@ class ExpressionImportlibResourcesBackportFilesCallBase(
     spec = importlib_resources_backport_files_spec
 
     def __init__(self, package, source_ref):
+
         ChildHavingPackageMixin.__init__(
             self,
             package=package,
@@ -1226,9 +1242,9 @@ class ExpressionImportlibResourcesBackportReadBinaryRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibResourcesBackportReadBinaryRef
-] = importlib_resources_backport_read_binary_spec
+hard_import_node_classes[ExpressionImportlibResourcesBackportReadBinaryRef] = (
+    importlib_resources_backport_read_binary_spec
+)
 
 
 class ExpressionImportlibResourcesBackportReadBinaryCallBase(
@@ -1249,6 +1265,7 @@ class ExpressionImportlibResourcesBackportReadBinaryCallBase(
     spec = importlib_resources_backport_read_binary_spec
 
     def __init__(self, package, resource, source_ref):
+
         ChildrenHavingPackageResourceMixin.__init__(
             self,
             package=package,
@@ -1326,9 +1343,9 @@ class ExpressionImportlibResourcesBackportReadTextRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibResourcesBackportReadTextRef
-] = importlib_resources_backport_read_text_spec
+hard_import_node_classes[ExpressionImportlibResourcesBackportReadTextRef] = (
+    importlib_resources_backport_read_text_spec
+)
 
 
 class ExpressionImportlibResourcesBackportReadTextCallBase(
@@ -1353,6 +1370,7 @@ class ExpressionImportlibResourcesBackportReadTextCallBase(
     spec = importlib_resources_backport_read_text_spec
 
     def __init__(self, package, resource, encoding, errors, source_ref):
+
         ChildrenHavingPackageResourceEncodingOptionalErrorsOptionalMixin.__init__(
             self,
             package=package,
@@ -1432,9 +1450,9 @@ class ExpressionImportlibResourcesFilesRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibResourcesFilesRef
-] = importlib_resources_files_spec
+hard_import_node_classes[ExpressionImportlibResourcesFilesRef] = (
+    importlib_resources_files_spec
+)
 
 
 class ExpressionImportlibResourcesFilesCallBase(
@@ -1452,6 +1470,7 @@ class ExpressionImportlibResourcesFilesCallBase(
     spec = importlib_resources_files_spec
 
     def __init__(self, package, source_ref):
+
         ChildHavingPackageMixin.__init__(
             self,
             package=package,
@@ -1459,8 +1478,7 @@ class ExpressionImportlibResourcesFilesCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if (
@@ -1525,9 +1543,9 @@ class ExpressionImportlibResourcesReadBinaryRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibResourcesReadBinaryRef
-] = importlib_resources_read_binary_spec
+hard_import_node_classes[ExpressionImportlibResourcesReadBinaryRef] = (
+    importlib_resources_read_binary_spec
+)
 
 
 class ExpressionImportlibResourcesReadBinaryCallBase(
@@ -1548,6 +1566,7 @@ class ExpressionImportlibResourcesReadBinaryCallBase(
     spec = importlib_resources_read_binary_spec
 
     def __init__(self, package, resource, source_ref):
+
         ChildrenHavingPackageResourceMixin.__init__(
             self,
             package=package,
@@ -1556,8 +1575,7 @@ class ExpressionImportlibResourcesReadBinaryCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if (
@@ -1625,9 +1643,9 @@ class ExpressionImportlibResourcesReadTextRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionImportlibResourcesReadTextRef
-] = importlib_resources_read_text_spec
+hard_import_node_classes[ExpressionImportlibResourcesReadTextRef] = (
+    importlib_resources_read_text_spec
+)
 
 
 class ExpressionImportlibResourcesReadTextCallBase(
@@ -1652,6 +1670,7 @@ class ExpressionImportlibResourcesReadTextCallBase(
     spec = importlib_resources_read_text_spec
 
     def __init__(self, package, resource, encoding, errors, source_ref):
+
         ChildrenHavingPackageResourceEncodingOptionalErrorsOptionalMixin.__init__(
             self,
             package=package,
@@ -1662,8 +1681,7 @@ class ExpressionImportlibResourcesReadTextCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if (
@@ -1745,6 +1763,7 @@ class ExpressionOsListdirCallBase(ChildHavingPathOptionalMixin, ExpressionBase):
     spec = os_listdir_spec
 
     def __init__(self, path, source_ref):
+
         ChildHavingPathOptionalMixin.__init__(
             self,
             path=path,
@@ -1752,8 +1771,7 @@ class ExpressionOsListdirCallBase(ChildHavingPathOptionalMixin, ExpressionBase):
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not os_listdir_spec.isCompileTimeComputable(
@@ -1777,6 +1795,94 @@ class ExpressionOsListdirCallBase(ChildHavingPathOptionalMixin, ExpressionBase):
         return True
 
 
+class ExpressionOsLstatRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.lstat"""
+
+    kind = "EXPRESSION_OS_LSTAT_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="os",
+            import_name="lstat",
+            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 ExpressionOsLstatCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsLstatCall,
+            builtin_spec=os_lstat_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.lstat' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsLstatRef] = os_lstat_spec
+
+
+class ExpressionOsLstatCallBase(
+    ChildrenHavingPathOptionalDirFdOptionalMixin, ExpressionBase
+):
+    """Base class for OsLstatCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = (
+        "path|optional",
+        "dir_fd|optional",
+    )
+
+    __slots__ = ("attempted",)
+
+    spec = os_lstat_spec
+
+    def __init__(self, path, dir_fd, source_ref):
+
+        ChildrenHavingPathOptionalDirFdOptionalMixin.__init__(
+            self,
+            path=path,
+            dir_fd=dir_fd,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not os_lstat_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 ExpressionOsPathAbspathRef(ExpressionImportModuleNameHardExistsSpecificBase):
     """Function reference os.path.abspath"""
 
@@ -1827,6 +1933,7 @@ class ExpressionOsPathAbspathCallBase(ChildHavingPathMixin, ExpressionBase):
     spec = os_path_abspath_spec
 
     def __init__(self, path, source_ref):
+
         ChildHavingPathMixin.__init__(
             self,
             path=path,
@@ -1834,8 +1941,7 @@ class ExpressionOsPathAbspathCallBase(ChildHavingPathMixin, ExpressionBase):
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not os_path_abspath_spec.isCompileTimeComputable(
@@ -1909,6 +2015,7 @@ class ExpressionOsPathBasenameCallBase(ChildHavingPMixin, ExpressionBase):
     spec = os_path_basename_spec
 
     def __init__(self, p, source_ref):
+
         ChildHavingPMixin.__init__(
             self,
             p=p,
@@ -1916,8 +2023,7 @@ class ExpressionOsPathBasenameCallBase(ChildHavingPMixin, ExpressionBase):
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not os_path_basename_spec.isCompileTimeComputable(
@@ -1941,6 +2047,88 @@ class ExpressionOsPathBasenameCallBase(ChildHavingPMixin, ExpressionBase):
         return True
 
 
+class ExpressionOsPathDirnameRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.path.dirname"""
+
+    kind = "EXPRESSION_OS_PATH_DIRNAME_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name=os.path.__name__,
+            import_name="dirname",
+            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 ExpressionOsPathDirnameCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsPathDirnameCall,
+            builtin_spec=os_path_dirname_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.path.dirname' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsPathDirnameRef] = os_path_dirname_spec
+
+
+class ExpressionOsPathDirnameCallBase(ChildHavingPMixin, ExpressionBase):
+    """Base class for OsPathDirnameCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = ("p",)
+
+    __slots__ = ("attempted",)
+
+    spec = os_path_dirname_spec
+
+    def __init__(self, p, source_ref):
+
+        ChildHavingPMixin.__init__(
+            self,
+            p=p,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not os_path_dirname_spec.isCompileTimeComputable(
+            (self.subnode_p,)
+        ):
+            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 ExpressionOsPathExistsRef(ExpressionImportModuleNameHardExistsSpecificBase):
     """Function reference os.path.exists"""
 
@@ -1991,6 +2179,7 @@ class ExpressionOsPathExistsCallBase(ChildHavingPathMixin, ExpressionBase):
     spec = os_path_exists_spec
 
     def __init__(self, path, source_ref):
+
         ChildHavingPathMixin.__init__(
             self,
             path=path,
@@ -1998,8 +2187,7 @@ class ExpressionOsPathExistsCallBase(ChildHavingPathMixin, ExpressionBase):
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not os_path_exists_spec.isCompileTimeComputable(
@@ -2075,6 +2263,7 @@ class ExpressionOsPathIsabsCallBase(
     spec = os_path_isabs_spec
 
     def __init__(self, s, source_ref):
+
         ChildHavingSMixin.__init__(
             self,
             s=s,
@@ -2082,8 +2271,7 @@ class ExpressionOsPathIsabsCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not os_path_isabs_spec.isCompileTimeComputable(
@@ -2157,6 +2345,7 @@ class ExpressionOsPathIsdirCallBase(ChildHavingPathMixin, ExpressionBase):
     spec = os_path_isdir_spec
 
     def __init__(self, path, source_ref):
+
         ChildHavingPathMixin.__init__(
             self,
             path=path,
@@ -2164,8 +2353,7 @@ class ExpressionOsPathIsdirCallBase(ChildHavingPathMixin, ExpressionBase):
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not os_path_isdir_spec.isCompileTimeComputable(
@@ -2239,6 +2427,7 @@ class ExpressionOsPathIsfileCallBase(ChildHavingPathMixin, ExpressionBase):
     spec = os_path_isfile_spec
 
     def __init__(self, path, source_ref):
+
         ChildHavingPathMixin.__init__(
             self,
             path=path,
@@ -2246,8 +2435,7 @@ class ExpressionOsPathIsfileCallBase(ChildHavingPathMixin, ExpressionBase):
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not os_path_isfile_spec.isCompileTimeComputable(
@@ -2271,16 +2459,16 @@ class ExpressionOsPathIsfileCallBase(ChildHavingPathMixin, ExpressionBase):
         return True
 
 
-class ExpressionOsUnameRef(ExpressionImportModuleNameHardExistsSpecificBase):
-    """Function reference os.uname"""
+class ExpressionOsPathNormpathRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.path.normpath"""
 
-    kind = "EXPRESSION_OS_UNAME_REF"
+    kind = "EXPRESSION_OS_PATH_NORMPATH_REF"
 
     def __init__(self, source_ref):
         ExpressionImportModuleNameHardExistsSpecificBase.__init__(
             self,
-            module_name="os",
-            import_name="uname",
+            module_name=os.path.__name__,
+            import_name="normpath",
             module_guaranteed=True,
             source_ref=source_ref,
         )
@@ -2290,45 +2478,217 @@ class ExpressionOsUnameRef(ExpressionImportModuleNameHardExistsSpecificBase):
         # replaced, we might be better but not now.
         trace_collection.onExceptionRaiseExit(BaseException)
 
-        from .OsSysNodes import ExpressionOsUnameCall
+        from .OsSysNodes import ExpressionOsPathNormpathCall
 
         result = extractBuiltinArgs(
             node=call_node,
-            builtin_class=ExpressionOsUnameCall,
-            builtin_spec=os_uname_spec,
+            builtin_class=ExpressionOsPathNormpathCall,
+            builtin_spec=os_path_normpath_spec,
         )
 
         return (
             result,
             "new_expression",
-            "Call to 'os.uname' recognized.",
+            "Call to 'os.path.normpath' recognized.",
         )
 
 
-hard_import_node_classes[ExpressionOsUnameRef] = os_uname_spec
+hard_import_node_classes[ExpressionOsPathNormpathRef] = os_path_normpath_spec
 
 
-class ExpressionOsUnameCallBase(ExpressionBase):
-    """Base class for OsUnameCall
+class ExpressionOsPathNormpathCallBase(ChildHavingPathMixin, ExpressionBase):
+    """Base class for OsPathNormpathCall
 
     Generated boiler plate code.
     """
 
+    named_children = ("path",)
+
     __slots__ = ("attempted",)
 
-    spec = os_uname_spec
+    spec = os_path_normpath_spec
 
-    def __init__(self, source_ref):
-        ExpressionBase.__init__(self, source_ref)
+    def __init__(self, path, source_ref):
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        ChildHavingPathMixin.__init__(
+            self,
+            path=path,
+        )
 
-    def finalize(self):
-        del self.parent
+        ExpressionBase.__init__(self, source_ref)
 
-    def computeExpressionRaw(self, trace_collection):
-        if self.attempted:
+        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 ExpressionOsStatRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.stat"""
+
+    kind = "EXPRESSION_OS_STAT_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="os",
+            import_name="stat",
+            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 ExpressionOsStatCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsStatCall,
+            builtin_spec=os_stat_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.stat' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsStatRef] = os_stat_spec
+
+
+class ExpressionOsStatCallBase(
+    ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin, ExpressionBase
+):
+    """Base class for OsStatCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = (
+        "path|optional",
+        "dir_fd|optional",
+        "follow_symlinks|optional",
+    )
+
+    __slots__ = ("attempted",)
+
+    spec = os_stat_spec
+
+    def __init__(self, path, dir_fd, follow_symlinks, source_ref):
+
+        ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin.__init__(
+            self,
+            path=path,
+            dir_fd=dir_fd,
+            follow_symlinks=follow_symlinks,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not os_stat_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"""
+
+    kind = "EXPRESSION_OS_UNAME_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="os",
+            import_name="uname",
+            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 ExpressionOsUnameCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsUnameCall,
+            builtin_spec=os_uname_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.uname' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsUnameRef] = os_uname_spec
+
+
+class ExpressionOsUnameCallBase(ExpressionBase):
+    """Base class for OsUnameCall
+
+    Generated boiler plate code.
+    """
+
+    __slots__ = ("attempted",)
+
+    spec = os_uname_spec
+
+    def __init__(self, source_ref):
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def finalize(self):
+        del self.parent
+
+    def computeExpressionRaw(self, trace_collection):
+        if self.attempted:
             trace_collection.onExceptionRaiseExit(BaseException)
 
             return self, None, None
@@ -2385,9 +2745,9 @@ class ExpressionPkgResourcesGetDistributionRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionPkgResourcesGetDistributionRef
-] = pkg_resources_get_distribution_spec
+hard_import_node_classes[ExpressionPkgResourcesGetDistributionRef] = (
+    pkg_resources_get_distribution_spec
+)
 
 
 class ExpressionPkgResourcesGetDistributionCallBase(
@@ -2405,6 +2765,7 @@ class ExpressionPkgResourcesGetDistributionCallBase(
     spec = pkg_resources_get_distribution_spec
 
     def __init__(self, dist, source_ref):
+
         ChildHavingDistMixin.__init__(
             self,
             dist=dist,
@@ -2478,9 +2839,9 @@ class ExpressionPkgResourcesIterEntryPointsRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionPkgResourcesIterEntryPointsRef
-] = pkg_resources_iter_entry_points_spec
+hard_import_node_classes[ExpressionPkgResourcesIterEntryPointsRef] = (
+    pkg_resources_iter_entry_points_spec
+)
 
 
 class ExpressionPkgResourcesIterEntryPointsCallBase(
@@ -2501,6 +2862,7 @@ class ExpressionPkgResourcesIterEntryPointsCallBase(
     spec = pkg_resources_iter_entry_points_spec
 
     def __init__(self, group, name, source_ref):
+
         ChildrenHavingGroupNameOptionalMixin.__init__(
             self,
             group=group,
@@ -2594,6 +2956,7 @@ class ExpressionPkgResourcesRequireCallBase(
     spec = pkg_resources_require_spec
 
     def __init__(self, requirements, source_ref):
+
         ChildHavingRequirementsTupleMixin.__init__(
             self,
             requirements=requirements,
@@ -2664,9 +3027,9 @@ class ExpressionPkgResourcesResourceStreamRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionPkgResourcesResourceStreamRef
-] = pkg_resources_resource_stream_spec
+hard_import_node_classes[ExpressionPkgResourcesResourceStreamRef] = (
+    pkg_resources_resource_stream_spec
+)
 
 
 class ExpressionPkgResourcesResourceStreamCallBase(
@@ -2687,6 +3050,7 @@ class ExpressionPkgResourcesResourceStreamCallBase(
     spec = pkg_resources_resource_stream_spec
 
     def __init__(self, package_or_requirement, resource_name, source_ref):
+
         ChildrenHavingPackageOrRequirementResourceNameMixin.__init__(
             self,
             package_or_requirement=package_or_requirement,
@@ -2764,9 +3128,9 @@ class ExpressionPkgResourcesResourceStringRef(
         )
 
 
-hard_import_node_classes[
-    ExpressionPkgResourcesResourceStringRef
-] = pkg_resources_resource_string_spec
+hard_import_node_classes[ExpressionPkgResourcesResourceStringRef] = (
+    pkg_resources_resource_string_spec
+)
 
 
 class ExpressionPkgResourcesResourceStringCallBase(
@@ -2787,6 +3151,7 @@ class ExpressionPkgResourcesResourceStringCallBase(
     spec = pkg_resources_resource_string_spec
 
     def __init__(self, package_or_requirement, resource_name, source_ref):
+
         ChildrenHavingPackageOrRequirementResourceNameMixin.__init__(
             self,
             package_or_requirement=package_or_requirement,
@@ -2881,6 +3246,7 @@ class ExpressionPkgutilGetDataCallBase(
     spec = pkgutil_get_data_spec
 
     def __init__(self, package, resource, source_ref):
+
         ChildrenHavingPackageResourceMixin.__init__(
             self,
             package=package,
@@ -2889,8 +3255,7 @@ class ExpressionPkgutilGetDataCallBase(
 
         ExpressionBase.__init__(self, source_ref)
 
-        # In module mode, we expect a changing environment, cannot optimize this
-        self.attempted = shallMakeModule()
+        self.attempted = False
 
     def computeExpression(self, trace_collection):
         if self.attempted or not pkgutil_get_data_spec.isCompileTimeComputable(
@@ -2915,3 +3280,236 @@ class ExpressionPkgutilGetDataCallBase(
     @staticmethod
     def mayRaiseExceptionOperation():
         return True
+
+
+class ExpressionSysExitRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference sys.exit"""
+
+    kind = "EXPRESSION_SYS_EXIT_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="sys",
+            import_name="exit",
+            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 makeExpressionSysExitCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=makeExpressionSysExitCall,
+            builtin_spec=sys_exit_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'sys.exit' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionSysExitRef] = sys_exit_spec
+
+
+class ExpressionSysExitCallBase(ChildHavingExitCodeOptionalMixin, ExpressionBase):
+    """Base class for SysExitCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = ("exit_code|optional",)
+
+    __slots__ = ("attempted",)
+
+    spec = sys_exit_spec
+
+    def __init__(self, exit_code, source_ref):
+
+        ChildHavingExitCodeOptionalMixin.__init__(
+            self,
+            exit_code=exit_code,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        # In module mode, we expect a changing environment, cannot optimize this
+        self.attempted = shallMakeModule()
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not sys_exit_spec.isCompileTimeComputable(
+            (self.subnode_exit_code,)
+        ):
+            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 ExpressionTensorflowFunctionRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference tensorflow.function"""
+
+    kind = "EXPRESSION_TENSORFLOW_FUNCTION_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="tensorflow",
+            import_name="function",
+            module_guaranteed=not shallMakeModule(),
+            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 .TensorflowNodes import ExpressionTensorflowFunctionCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionTensorflowFunctionCall,
+            builtin_spec=tensorflow_function_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'tensorflow.function' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionTensorflowFunctionRef] = tensorflow_function_spec
+
+
+class ExpressionTensorflowFunctionCallBase(
+    ChildrenHavingFuncOptionalInputSignatureOptionalAutographOptionalJitCompileOptionalReduceRetracingOptionalExperimentalImplementsOptionalExperimentalAutographOptionsOptionalExperimentalAttributesOptionalExperimentalRelaxShapesOptionalExperimentalCompileOptionalExperimentalFollowTypeHintsOptionalMixin,
+    ExpressionBase,
+):
+    """Base class for TensorflowFunctionCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = (
+        "func|optional",
+        "input_signature|optional",
+        "autograph|optional",
+        "jit_compile|optional",
+        "reduce_retracing|optional",
+        "experimental_implements|optional",
+        "experimental_autograph_options|optional",
+        "experimental_attributes|optional",
+        "experimental_relax_shapes|optional",
+        "experimental_compile|optional",
+        "experimental_follow_type_hints|optional",
+    )
+
+    __slots__ = ("attempted",)
+
+    spec = tensorflow_function_spec
+
+    def __init__(
+        self,
+        func,
+        input_signature,
+        autograph,
+        jit_compile,
+        reduce_retracing,
+        experimental_implements,
+        experimental_autograph_options,
+        experimental_attributes,
+        experimental_relax_shapes,
+        experimental_compile,
+        experimental_follow_type_hints,
+        source_ref,
+    ):
+
+        ChildrenHavingFuncOptionalInputSignatureOptionalAutographOptionalJitCompileOptionalReduceRetracingOptionalExperimentalImplementsOptionalExperimentalAutographOptionsOptionalExperimentalAttributesOptionalExperimentalRelaxShapesOptionalExperimentalCompileOptionalExperimentalFollowTypeHintsOptionalMixin.__init__(
+            self,
+            func=func,
+            input_signature=input_signature,
+            autograph=autograph,
+            jit_compile=jit_compile,
+            reduce_retracing=reduce_retracing,
+            experimental_implements=experimental_implements,
+            experimental_autograph_options=experimental_autograph_options,
+            experimental_attributes=experimental_attributes,
+            experimental_relax_shapes=experimental_relax_shapes,
+            experimental_compile=experimental_compile,
+            experimental_follow_type_hints=experimental_follow_type_hints,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        # In module mode, we expect a changing environment, cannot optimize this
+        self.attempted = shallMakeModule()
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not tensorflow_function_spec.isCompileTimeComputable(
+            (
+                self.subnode_func,
+                self.subnode_input_signature,
+                self.subnode_autograph,
+                self.subnode_jit_compile,
+                self.subnode_reduce_retracing,
+                self.subnode_experimental_implements,
+                self.subnode_experimental_autograph_options,
+                self.subnode_experimental_attributes,
+                self.subnode_experimental_relax_shapes,
+                self.subnode_experimental_compile,
+                self.subnode_experimental_follow_type_hints,
+            )
+        ):
+            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
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.