Copy disabled (too large)
Download .txt
Showing preview only (24,433K chars total). Download the full file to get everything.
Repository: wasmerio/py2wasm
Branch: develop
Commit: 3136f77ae018
Files: 1940
Total size: 22.9 MB
Directory structure:
gitextract_8msbk7ao/
├── .editorconfig
├── .gitattributes
├── .githooks/
│ └── pre-commit
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ └── testing.yml
├── .gitignore
├── .gitmodules
├── .sourcery.yaml
├── .vscode/
│ ├── c_cpp_properties.json
│ ├── extensions.json
│ └── settings.json
├── CODE_OF_CONDUCT.rst
├── CONTRIBUTING.md
├── Changelog.rst
├── Developer_Manual.rst
├── LICENSE.txt
├── MANIFEST.in
├── README.rst
├── SECURITY.md
├── Standard-Plugins-Documentation.rst
├── UserPlugin-Creation.rst
├── Using-Plugin-Options.rst
├── bin/
│ ├── autoformat-nuitka-source
│ ├── check-nuitka-with-codespell
│ ├── check-nuitka-with-pylint
│ ├── check-nuitka-with-restlint
│ ├── check-nuitka-with-yamllint
│ ├── check-reference-counts
│ ├── compare_with_cpython
│ ├── compare_with_xml
│ ├── find_sxs_modules
│ ├── generate-specialized-c-code
│ ├── generate-specialized-python-code
│ ├── measure-construct-performance
│ ├── nuitka
│ ├── nuitka-run
│ ├── nuitka-watch
│ ├── nuitka3
│ ├── nuitka3-run
│ └── run-inside-nuitka-container
├── debian/
│ ├── README.source
│ ├── changelog
│ ├── compat
│ ├── control
│ ├── copyright
│ ├── nuitka.docs
│ ├── nuitka.manpages
│ ├── pbuilder-hookdir/
│ │ └── B92test-installed-nuitka
│ ├── rules
│ ├── source/
│ │ ├── format
│ │ └── lintian-overrides
│ ├── upstream-signing-key.pgp
│ └── watch
├── doc/
│ ├── Doxyfile.template
│ ├── custom.css
│ ├── nuitka-man-include.txt
│ ├── nuitka-run.1
│ ├── nuitka.1
│ └── uml/
│ ├── standalone-overview.plantuml
│ └── use-cases.plantuml
├── lib/
│ └── hints.py
├── misc/
│ ├── codespell-ignore.txt
│ ├── create-pbuilder-image.py
│ ├── dump-config-options.py
│ ├── install-git-hooks.py
│ ├── make-apidoc.py
│ ├── make-coverage-rendering.py
│ ├── make-deb-mentors-release.py
│ ├── make-deb-release.py
│ ├── make-pypi-upload.py
│ ├── make-release.py
│ ├── make-upload.py
│ ├── make-version-bump.py
│ ├── nuitka-package-config-schema.json
│ ├── nuitka-run.bat
│ ├── nuitka.bat
│ ├── run-valgrind.py
│ └── update-doc.py
├── nuitka/
│ ├── Builtins.py
│ ├── BytecodeCaching.py
│ ├── Bytecodes.py
│ ├── CacheCleanup.py
│ ├── Constants.py
│ ├── Errors.py
│ ├── HardImportRegistry.py
│ ├── MainControl.py
│ ├── ModuleRegistry.py
│ ├── OptionParsing.py
│ ├── Options.py
│ ├── OutputDirectories.py
│ ├── PostProcessing.py
│ ├── Progress.py
│ ├── PythonFlavors.py
│ ├── PythonOperators.py
│ ├── PythonVersions.py
│ ├── Serialization.py
│ ├── SourceCodeReferences.py
│ ├── Tracing.py
│ ├── TreeXML.py
│ ├── Variables.py
│ ├── Version.py
│ ├── __init__.py
│ ├── __main__.py
│ ├── __past__.py
│ ├── build/
│ │ ├── Backend.scons
│ │ ├── CCompilerVersion.scons
│ │ ├── DataComposerInterface.py
│ │ ├── Onefile.scons
│ │ ├── SconsCaching.py
│ │ ├── SconsCompilerSettings.py
│ │ ├── SconsHacks.py
│ │ ├── SconsInterface.py
│ │ ├── SconsProgress.py
│ │ ├── SconsSpawn.py
│ │ ├── SconsUtils.py
│ │ ├── __init__.py
│ │ ├── include/
│ │ │ └── nuitka/
│ │ │ ├── allocator.h
│ │ │ ├── builtins.h
│ │ │ ├── calling.h
│ │ │ ├── checkers.h
│ │ │ ├── checksum_tools.h
│ │ │ ├── compiled_asyncgen.h
│ │ │ ├── compiled_cell.h
│ │ │ ├── compiled_coroutine.h
│ │ │ ├── compiled_frame.h
│ │ │ ├── compiled_function.h
│ │ │ ├── compiled_generator.h
│ │ │ ├── compiled_method.h
│ │ │ ├── constants.h
│ │ │ ├── constants_blob.h
│ │ │ ├── environment_variables.h
│ │ │ ├── environment_variables_system.h
│ │ │ ├── exception_groups.h
│ │ │ ├── exceptions.h
│ │ │ ├── filesystem_paths.h
│ │ │ ├── freelists.h
│ │ │ ├── hedley.h
│ │ │ ├── helper/
│ │ │ │ ├── attributes.h
│ │ │ │ ├── boolean.h
│ │ │ │ ├── bytearrays.h
│ │ │ │ ├── bytes.h
│ │ │ │ ├── calling_generated.h
│ │ │ │ ├── comparisons_eq.h
│ │ │ │ ├── comparisons_ge.h
│ │ │ │ ├── comparisons_gt.h
│ │ │ │ ├── comparisons_le.h
│ │ │ │ ├── comparisons_lt.h
│ │ │ │ ├── comparisons_ne.h
│ │ │ │ ├── complex.h
│ │ │ │ ├── dictionaries.h
│ │ │ │ ├── floats.h
│ │ │ │ ├── import_hard.h
│ │ │ │ ├── indexes.h
│ │ │ │ ├── ints.h
│ │ │ │ ├── iterators.h
│ │ │ │ ├── lists.h
│ │ │ │ ├── lists_generated.h
│ │ │ │ ├── mappings.h
│ │ │ │ ├── operations.h
│ │ │ │ ├── operations_binary_add.h
│ │ │ │ ├── operations_binary_bitand.h
│ │ │ │ ├── operations_binary_bitor.h
│ │ │ │ ├── operations_binary_bitxor.h
│ │ │ │ ├── operations_binary_divmod.h
│ │ │ │ ├── operations_binary_floordiv.h
│ │ │ │ ├── operations_binary_lshift.h
│ │ │ │ ├── operations_binary_matmult.h
│ │ │ │ ├── operations_binary_mod.h
│ │ │ │ ├── operations_binary_mult.h
│ │ │ │ ├── operations_binary_olddiv.h
│ │ │ │ ├── operations_binary_pow.h
│ │ │ │ ├── operations_binary_rshift.h
│ │ │ │ ├── operations_binary_sub.h
│ │ │ │ ├── operations_binary_truediv.h
│ │ │ │ ├── operations_builtin_types.h
│ │ │ │ ├── operations_inplace_add.h
│ │ │ │ ├── operations_inplace_bitand.h
│ │ │ │ ├── operations_inplace_bitor.h
│ │ │ │ ├── operations_inplace_bitxor.h
│ │ │ │ ├── operations_inplace_floordiv.h
│ │ │ │ ├── operations_inplace_lshift.h
│ │ │ │ ├── operations_inplace_matmult.h
│ │ │ │ ├── operations_inplace_mod.h
│ │ │ │ ├── operations_inplace_mult.h
│ │ │ │ ├── operations_inplace_olddiv.h
│ │ │ │ ├── operations_inplace_pow.h
│ │ │ │ ├── operations_inplace_rshift.h
│ │ │ │ ├── operations_inplace_sub.h
│ │ │ │ ├── operations_inplace_truediv.h
│ │ │ │ ├── raising.h
│ │ │ │ ├── rangeobjects.h
│ │ │ │ ├── richcomparisons.h
│ │ │ │ ├── sequences.h
│ │ │ │ ├── sets.h
│ │ │ │ ├── slices.h
│ │ │ │ ├── strings.h
│ │ │ │ ├── subscripts.h
│ │ │ │ └── tuples.h
│ │ │ ├── helpers.h
│ │ │ ├── importing.h
│ │ │ ├── incbin.h
│ │ │ ├── jit_sources.h
│ │ │ ├── prelude.h
│ │ │ ├── printing.h
│ │ │ ├── python_pgo.h
│ │ │ ├── safe_string_ops.h
│ │ │ ├── threading.h
│ │ │ ├── tracing.h
│ │ │ └── unfreezing.h
│ │ ├── inline_copy/
│ │ │ ├── appdirs/
│ │ │ │ ├── LICENSE.txt
│ │ │ │ └── appdirs.py
│ │ │ ├── atomicwrites/
│ │ │ │ ├── LICENSE
│ │ │ │ └── atomicwrites.py
│ │ │ ├── bin/
│ │ │ │ └── scons.py
│ │ │ ├── clcache/
│ │ │ │ └── clcache/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── __init__.py
│ │ │ │ └── caching.py
│ │ │ ├── colorama/
│ │ │ │ ├── LICENSE.txt
│ │ │ │ └── colorama/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── ansi.py
│ │ │ │ ├── ansitowin32.py
│ │ │ │ ├── initialise.py
│ │ │ │ ├── win32.py
│ │ │ │ └── winterm.py
│ │ │ ├── glob2/
│ │ │ │ ├── LICENSE
│ │ │ │ └── glob2/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── compat.py
│ │ │ │ ├── fnmatch.py
│ │ │ │ └── impl.py
│ │ │ ├── jinja2/
│ │ │ │ ├── LICENSE.rst
│ │ │ │ ├── README.rst
│ │ │ │ └── jinja2/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _compat.py
│ │ │ │ ├── _identifier.py
│ │ │ │ ├── bccache.py
│ │ │ │ ├── compiler.py
│ │ │ │ ├── constants.py
│ │ │ │ ├── debug.py
│ │ │ │ ├── defaults.py
│ │ │ │ ├── environment.py
│ │ │ │ ├── exceptions.py
│ │ │ │ ├── ext.py
│ │ │ │ ├── filters.py
│ │ │ │ ├── idtracking.py
│ │ │ │ ├── lexer.py
│ │ │ │ ├── loaders.py
│ │ │ │ ├── meta.py
│ │ │ │ ├── nativetypes.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── optimizer.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── runtime.py
│ │ │ │ ├── sandbox.py
│ │ │ │ ├── tests.py
│ │ │ │ ├── utils.py
│ │ │ │ └── visitor.py
│ │ │ ├── jinja2_35/
│ │ │ │ ├── LICENSE.rst
│ │ │ │ ├── README.rst
│ │ │ │ └── jinja2/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _compat.py
│ │ │ │ ├── _identifier.py
│ │ │ │ ├── bccache.py
│ │ │ │ ├── compiler.py
│ │ │ │ ├── constants.py
│ │ │ │ ├── debug.py
│ │ │ │ ├── defaults.py
│ │ │ │ ├── environment.py
│ │ │ │ ├── exceptions.py
│ │ │ │ ├── ext.py
│ │ │ │ ├── filters.py
│ │ │ │ ├── idtracking.py
│ │ │ │ ├── lexer.py
│ │ │ │ ├── loaders.py
│ │ │ │ ├── meta.py
│ │ │ │ ├── nativetypes.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── optimizer.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── runtime.py
│ │ │ │ ├── sandbox.py
│ │ │ │ ├── tests.py
│ │ │ │ ├── utils.py
│ │ │ │ └── visitor.py
│ │ │ ├── lib/
│ │ │ │ ├── scons-2.3.2/
│ │ │ │ │ └── SCons/
│ │ │ │ │ ├── Action.py
│ │ │ │ │ ├── Builder.py
│ │ │ │ │ ├── CacheDir.py
│ │ │ │ │ ├── Conftest.py
│ │ │ │ │ ├── Debug.py
│ │ │ │ │ ├── Defaults.py
│ │ │ │ │ ├── Environment.py
│ │ │ │ │ ├── Errors.py
│ │ │ │ │ ├── Executor.py
│ │ │ │ │ ├── Job.py
│ │ │ │ │ ├── Memoize.py
│ │ │ │ │ ├── Node/
│ │ │ │ │ │ ├── Alias.py
│ │ │ │ │ │ ├── FS.py
│ │ │ │ │ │ ├── Python.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Options/
│ │ │ │ │ │ ├── BoolOption.py
│ │ │ │ │ │ ├── EnumOption.py
│ │ │ │ │ │ ├── ListOption.py
│ │ │ │ │ │ ├── PackageOption.py
│ │ │ │ │ │ ├── PathOption.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── PathList.py
│ │ │ │ │ ├── Platform/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aix.py
│ │ │ │ │ │ ├── cygwin.py
│ │ │ │ │ │ ├── darwin.py
│ │ │ │ │ │ ├── hpux.py
│ │ │ │ │ │ ├── irix.py
│ │ │ │ │ │ ├── os2.py
│ │ │ │ │ │ ├── posix.py
│ │ │ │ │ │ ├── sunos.py
│ │ │ │ │ │ └── win32.py
│ │ │ │ │ ├── SConf.py
│ │ │ │ │ ├── SConsign.py
│ │ │ │ │ ├── Scanner/
│ │ │ │ │ │ ├── C.py
│ │ │ │ │ │ ├── Dir.py
│ │ │ │ │ │ ├── Prog.py
│ │ │ │ │ │ ├── RC.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Script/
│ │ │ │ │ │ ├── Interactive.py
│ │ │ │ │ │ ├── Main.py
│ │ │ │ │ │ ├── SConsOptions.py
│ │ │ │ │ │ ├── SConscript.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Sig.py
│ │ │ │ │ ├── Subst.py
│ │ │ │ │ ├── Taskmaster.py
│ │ │ │ │ ├── Tool/
│ │ │ │ │ │ ├── 386asm.py
│ │ │ │ │ │ ├── BitKeeper.py
│ │ │ │ │ │ ├── CVS.py
│ │ │ │ │ │ ├── GettextCommon.py
│ │ │ │ │ │ ├── MSCommon/
│ │ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ │ ├── arch.py
│ │ │ │ │ │ │ ├── common.py
│ │ │ │ │ │ │ ├── netframework.py
│ │ │ │ │ │ │ ├── sdk.py
│ │ │ │ │ │ │ ├── vc.py
│ │ │ │ │ │ │ └── vs.py
│ │ │ │ │ │ ├── Perforce.py
│ │ │ │ │ │ ├── PharLapCommon.py
│ │ │ │ │ │ ├── RCS.py
│ │ │ │ │ │ ├── SCCS.py
│ │ │ │ │ │ ├── Subversion.py
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aixc++.py
│ │ │ │ │ │ ├── aixcc.py
│ │ │ │ │ │ ├── aixf77.py
│ │ │ │ │ │ ├── aixlink.py
│ │ │ │ │ │ ├── applelink.py
│ │ │ │ │ │ ├── ar.py
│ │ │ │ │ │ ├── as.py
│ │ │ │ │ │ ├── bcc32.py
│ │ │ │ │ │ ├── c++.py
│ │ │ │ │ │ ├── cc.py
│ │ │ │ │ │ ├── cyglink.py
│ │ │ │ │ │ ├── default.py
│ │ │ │ │ │ ├── dmd.py
│ │ │ │ │ │ ├── docbook/
│ │ │ │ │ │ │ └── __init__.py
│ │ │ │ │ │ ├── filesystem.py
│ │ │ │ │ │ ├── g++.py
│ │ │ │ │ │ ├── g77.py
│ │ │ │ │ │ ├── gas.py
│ │ │ │ │ │ ├── gcc.py
│ │ │ │ │ │ ├── gdc.py
│ │ │ │ │ │ ├── gettext.py
│ │ │ │ │ │ ├── gfortran.py
│ │ │ │ │ │ ├── gnulink.py
│ │ │ │ │ │ ├── hpc++.py
│ │ │ │ │ │ ├── hpcc.py
│ │ │ │ │ │ ├── hplink.py
│ │ │ │ │ │ ├── icc.py
│ │ │ │ │ │ ├── icl.py
│ │ │ │ │ │ ├── ilink.py
│ │ │ │ │ │ ├── ilink32.py
│ │ │ │ │ │ ├── install.py
│ │ │ │ │ │ ├── intelc.py
│ │ │ │ │ │ ├── lex.py
│ │ │ │ │ │ ├── link.py
│ │ │ │ │ │ ├── linkloc.py
│ │ │ │ │ │ ├── m4.py
│ │ │ │ │ │ ├── masm.py
│ │ │ │ │ │ ├── mingw.py
│ │ │ │ │ │ ├── msgfmt.py
│ │ │ │ │ │ ├── msginit.py
│ │ │ │ │ │ ├── msgmerge.py
│ │ │ │ │ │ ├── mslib.py
│ │ │ │ │ │ ├── mslink.py
│ │ │ │ │ │ ├── mssdk.py
│ │ │ │ │ │ ├── msvc.py
│ │ │ │ │ │ ├── msvs.py
│ │ │ │ │ │ ├── mwcc.py
│ │ │ │ │ │ ├── mwld.py
│ │ │ │ │ │ ├── nasm.py
│ │ │ │ │ │ ├── rmic.py
│ │ │ │ │ │ ├── rpcgen.py
│ │ │ │ │ │ ├── sgiar.py
│ │ │ │ │ │ ├── sgic++.py
│ │ │ │ │ │ ├── sgicc.py
│ │ │ │ │ │ ├── sgilink.py
│ │ │ │ │ │ ├── sunar.py
│ │ │ │ │ │ ├── sunc++.py
│ │ │ │ │ │ ├── suncc.py
│ │ │ │ │ │ ├── sunlink.py
│ │ │ │ │ │ ├── tar.py
│ │ │ │ │ │ ├── textfile.py
│ │ │ │ │ │ ├── tlib.py
│ │ │ │ │ │ ├── wix.py
│ │ │ │ │ │ ├── xgettext.py
│ │ │ │ │ │ └── zip.py
│ │ │ │ │ ├── Util.py
│ │ │ │ │ ├── Variables/
│ │ │ │ │ │ ├── BoolVariable.py
│ │ │ │ │ │ ├── EnumVariable.py
│ │ │ │ │ │ ├── ListVariable.py
│ │ │ │ │ │ ├── PackageVariable.py
│ │ │ │ │ │ ├── PathVariable.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Warnings.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── compat/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── _scons_builtins.py
│ │ │ │ │ │ ├── _scons_collections.py
│ │ │ │ │ │ ├── _scons_dbm.py
│ │ │ │ │ │ ├── _scons_hashlib.py
│ │ │ │ │ │ ├── _scons_io.py
│ │ │ │ │ │ ├── _scons_sets.py
│ │ │ │ │ │ └── _scons_subprocess.py
│ │ │ │ │ ├── cpp.py
│ │ │ │ │ ├── dblite.py
│ │ │ │ │ └── exitfuncs.py
│ │ │ │ ├── scons-3.1.2/
│ │ │ │ │ └── SCons/
│ │ │ │ │ ├── Action.py
│ │ │ │ │ ├── Builder.py
│ │ │ │ │ ├── CacheDir.py
│ │ │ │ │ ├── Conftest.py
│ │ │ │ │ ├── Debug.py
│ │ │ │ │ ├── Defaults.py
│ │ │ │ │ ├── Environment.py
│ │ │ │ │ ├── Errors.py
│ │ │ │ │ ├── Executor.py
│ │ │ │ │ ├── Job.py
│ │ │ │ │ ├── Memoize.py
│ │ │ │ │ ├── Node/
│ │ │ │ │ │ ├── Alias.py
│ │ │ │ │ │ ├── FS.py
│ │ │ │ │ │ ├── Python.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── PathList.py
│ │ │ │ │ ├── Platform/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aix.py
│ │ │ │ │ │ ├── cygwin.py
│ │ │ │ │ │ ├── darwin.py
│ │ │ │ │ │ ├── hpux.py
│ │ │ │ │ │ ├── irix.py
│ │ │ │ │ │ ├── mingw.py
│ │ │ │ │ │ ├── os2.py
│ │ │ │ │ │ ├── posix.py
│ │ │ │ │ │ ├── sunos.py
│ │ │ │ │ │ ├── virtualenv.py
│ │ │ │ │ │ └── win32.py
│ │ │ │ │ ├── SConf.py
│ │ │ │ │ ├── SConsign.py
│ │ │ │ │ ├── Scanner/
│ │ │ │ │ │ ├── C.py
│ │ │ │ │ │ ├── Dir.py
│ │ │ │ │ │ ├── Prog.py
│ │ │ │ │ │ ├── RC.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Script/
│ │ │ │ │ │ ├── Interactive.py
│ │ │ │ │ │ ├── Main.py
│ │ │ │ │ │ ├── SConsOptions.py
│ │ │ │ │ │ ├── SConscript.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Subst.py
│ │ │ │ │ ├── Taskmaster.py
│ │ │ │ │ ├── Tool/
│ │ │ │ │ │ ├── 386asm.py
│ │ │ │ │ │ ├── GettextCommon.py
│ │ │ │ │ │ ├── MSCommon/
│ │ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ │ ├── arch.py
│ │ │ │ │ │ │ ├── common.py
│ │ │ │ │ │ │ ├── netframework.py
│ │ │ │ │ │ │ ├── sdk.py
│ │ │ │ │ │ │ ├── vc.py
│ │ │ │ │ │ │ └── vs.py
│ │ │ │ │ │ ├── PharLapCommon.py
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aixc++.py
│ │ │ │ │ │ ├── aixcc.py
│ │ │ │ │ │ ├── aixcxx.py
│ │ │ │ │ │ ├── aixlink.py
│ │ │ │ │ │ ├── applelink.py
│ │ │ │ │ │ ├── ar.py
│ │ │ │ │ │ ├── as.py
│ │ │ │ │ │ ├── bcc32.py
│ │ │ │ │ │ ├── c++.py
│ │ │ │ │ │ ├── cc.py
│ │ │ │ │ │ ├── clang.py
│ │ │ │ │ │ ├── clangCommon/
│ │ │ │ │ │ │ └── __init__.py
│ │ │ │ │ │ ├── clangxx.py
│ │ │ │ │ │ ├── cxx.py
│ │ │ │ │ │ ├── cyglink.py
│ │ │ │ │ │ ├── default.py
│ │ │ │ │ │ ├── docbook/
│ │ │ │ │ │ │ └── __init__.py
│ │ │ │ │ │ ├── filesystem.py
│ │ │ │ │ │ ├── g++.py
│ │ │ │ │ │ ├── gas.py
│ │ │ │ │ │ ├── gcc.py
│ │ │ │ │ │ ├── gettext_tool.py
│ │ │ │ │ │ ├── gnulink.py
│ │ │ │ │ │ ├── gxx.py
│ │ │ │ │ │ ├── hpc++.py
│ │ │ │ │ │ ├── hpcc.py
│ │ │ │ │ │ ├── hpcxx.py
│ │ │ │ │ │ ├── hplink.py
│ │ │ │ │ │ ├── icc.py
│ │ │ │ │ │ ├── icl.py
│ │ │ │ │ │ ├── ilink.py
│ │ │ │ │ │ ├── ilink32.py
│ │ │ │ │ │ ├── install.py
│ │ │ │ │ │ ├── intelc.py
│ │ │ │ │ │ ├── link.py
│ │ │ │ │ │ ├── linkloc.py
│ │ │ │ │ │ ├── m4.py
│ │ │ │ │ │ ├── masm.py
│ │ │ │ │ │ ├── mingw.py
│ │ │ │ │ │ ├── msgfmt.py
│ │ │ │ │ │ ├── msginit.py
│ │ │ │ │ │ ├── msgmerge.py
│ │ │ │ │ │ ├── mslib.py
│ │ │ │ │ │ ├── mslink.py
│ │ │ │ │ │ ├── mssdk.py
│ │ │ │ │ │ ├── msvc.py
│ │ │ │ │ │ ├── msvs.py
│ │ │ │ │ │ ├── mwcc.py
│ │ │ │ │ │ ├── mwld.py
│ │ │ │ │ │ ├── nasm.py
│ │ │ │ │ │ ├── rmic.py
│ │ │ │ │ │ ├── rpcgen.py
│ │ │ │ │ │ ├── sgiar.py
│ │ │ │ │ │ ├── sgic++.py
│ │ │ │ │ │ ├── sgicc.py
│ │ │ │ │ │ ├── sgicxx.py
│ │ │ │ │ │ ├── sgilink.py
│ │ │ │ │ │ ├── sunar.py
│ │ │ │ │ │ ├── sunc++.py
│ │ │ │ │ │ ├── suncc.py
│ │ │ │ │ │ ├── suncxx.py
│ │ │ │ │ │ ├── sunlink.py
│ │ │ │ │ │ ├── tar.py
│ │ │ │ │ │ ├── textfile.py
│ │ │ │ │ │ ├── tlib.py
│ │ │ │ │ │ ├── wix.py
│ │ │ │ │ │ ├── xgettext.py
│ │ │ │ │ │ └── zip.py
│ │ │ │ │ ├── Util.py
│ │ │ │ │ ├── Variables/
│ │ │ │ │ │ ├── BoolVariable.py
│ │ │ │ │ │ ├── EnumVariable.py
│ │ │ │ │ │ ├── ListVariable.py
│ │ │ │ │ │ ├── PackageVariable.py
│ │ │ │ │ │ ├── PathVariable.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Warnings.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── compat/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ └── _scons_dbm.py
│ │ │ │ │ ├── cpp.py
│ │ │ │ │ ├── dblite.py
│ │ │ │ │ └── exitfuncs.py
│ │ │ │ └── scons-4.3.0/
│ │ │ │ └── SCons/
│ │ │ │ ├── Action.py
│ │ │ │ ├── Builder.py
│ │ │ │ ├── CacheDir.py
│ │ │ │ ├── Conftest.py
│ │ │ │ ├── Debug.py
│ │ │ │ ├── Defaults.py
│ │ │ │ ├── Environment.py
│ │ │ │ ├── EnvironmentValues.py
│ │ │ │ ├── Errors.py
│ │ │ │ ├── Executor.py
│ │ │ │ ├── Job.py
│ │ │ │ ├── Memoize.py
│ │ │ │ ├── Node/
│ │ │ │ │ ├── Alias.py
│ │ │ │ │ ├── FS.py
│ │ │ │ │ ├── Python.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── PathList.py
│ │ │ │ ├── Platform/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── aix.py
│ │ │ │ │ ├── cygwin.py
│ │ │ │ │ ├── darwin.py
│ │ │ │ │ ├── hpux.py
│ │ │ │ │ ├── irix.py
│ │ │ │ │ ├── mingw.py
│ │ │ │ │ ├── os2.py
│ │ │ │ │ ├── posix.py
│ │ │ │ │ ├── sunos.py
│ │ │ │ │ ├── virtualenv.py
│ │ │ │ │ └── win32.py
│ │ │ │ ├── SConf.py
│ │ │ │ ├── SConsign.py
│ │ │ │ ├── Scanner/
│ │ │ │ │ ├── C.py
│ │ │ │ │ ├── Dir.py
│ │ │ │ │ ├── Prog.py
│ │ │ │ │ ├── RC.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── Script/
│ │ │ │ │ ├── Interactive.py
│ │ │ │ │ ├── Main.py
│ │ │ │ │ ├── SConsOptions.py
│ │ │ │ │ ├── SConscript.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── Subst.py
│ │ │ │ ├── Taskmaster.py
│ │ │ │ ├── Tool/
│ │ │ │ │ ├── 386asm.py
│ │ │ │ │ ├── GettextCommon.py
│ │ │ │ │ ├── MSCommon/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── arch.py
│ │ │ │ │ │ ├── common.py
│ │ │ │ │ │ ├── netframework.py
│ │ │ │ │ │ ├── sdk.py
│ │ │ │ │ │ ├── vc.py
│ │ │ │ │ │ └── vs.py
│ │ │ │ │ ├── PharLapCommon.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── aixc++.py
│ │ │ │ │ ├── aixcc.py
│ │ │ │ │ ├── aixcxx.py
│ │ │ │ │ ├── aixlink.py
│ │ │ │ │ ├── applelink.py
│ │ │ │ │ ├── ar.py
│ │ │ │ │ ├── as.py
│ │ │ │ │ ├── asm.py
│ │ │ │ │ ├── bcc32.py
│ │ │ │ │ ├── c++.py
│ │ │ │ │ ├── cc.py
│ │ │ │ │ ├── clang.py
│ │ │ │ │ ├── clangCommon/
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── clangxx.py
│ │ │ │ │ ├── cxx.py
│ │ │ │ │ ├── cyglink.py
│ │ │ │ │ ├── default.py
│ │ │ │ │ ├── filesystem.py
│ │ │ │ │ ├── g++.py
│ │ │ │ │ ├── gas.py
│ │ │ │ │ ├── gcc.py
│ │ │ │ │ ├── gettext_tool.py
│ │ │ │ │ ├── gnulink.py
│ │ │ │ │ ├── gxx.py
│ │ │ │ │ ├── hpc++.py
│ │ │ │ │ ├── hpcc.py
│ │ │ │ │ ├── hpcxx.py
│ │ │ │ │ ├── hplink.py
│ │ │ │ │ ├── icc.py
│ │ │ │ │ ├── icl.py
│ │ │ │ │ ├── ilink.py
│ │ │ │ │ ├── ilink32.py
│ │ │ │ │ ├── install.py
│ │ │ │ │ ├── intelc.py
│ │ │ │ │ ├── link.py
│ │ │ │ │ ├── linkCommon/
│ │ │ │ │ │ ├── LoadableModule.py
│ │ │ │ │ │ ├── SharedLibrary.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── linkloc.py
│ │ │ │ │ ├── m4.py
│ │ │ │ │ ├── masm.py
│ │ │ │ │ ├── mingw.py
│ │ │ │ │ ├── msgfmt.py
│ │ │ │ │ ├── msginit.py
│ │ │ │ │ ├── msgmerge.py
│ │ │ │ │ ├── mslib.py
│ │ │ │ │ ├── mslink.py
│ │ │ │ │ ├── mssdk.py
│ │ │ │ │ ├── msvc.py
│ │ │ │ │ ├── msvs.py
│ │ │ │ │ ├── mwcc.py
│ │ │ │ │ ├── mwld.py
│ │ │ │ │ ├── nasm.py
│ │ │ │ │ ├── rmic.py
│ │ │ │ │ ├── rpcgen.py
│ │ │ │ │ ├── sgiar.py
│ │ │ │ │ ├── sgic++.py
│ │ │ │ │ ├── sgicc.py
│ │ │ │ │ ├── sgicxx.py
│ │ │ │ │ ├── sgilink.py
│ │ │ │ │ ├── sunar.py
│ │ │ │ │ ├── sunc++.py
│ │ │ │ │ ├── suncc.py
│ │ │ │ │ ├── suncxx.py
│ │ │ │ │ ├── sunlink.py
│ │ │ │ │ ├── tar.py
│ │ │ │ │ ├── textfile.py
│ │ │ │ │ ├── tlib.py
│ │ │ │ │ ├── wix.py
│ │ │ │ │ ├── xgettext.py
│ │ │ │ │ └── zip.py
│ │ │ │ ├── Util.py
│ │ │ │ ├── Utilities/
│ │ │ │ │ ├── ConfigureCache.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── sconsign.py
│ │ │ │ ├── Variables/
│ │ │ │ │ ├── BoolVariable.py
│ │ │ │ │ ├── EnumVariable.py
│ │ │ │ │ ├── ListVariable.py
│ │ │ │ │ ├── PackageVariable.py
│ │ │ │ │ ├── PathVariable.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── Warnings.py
│ │ │ │ ├── __init__.py
│ │ │ │ ├── compat/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── _scons_dbm.py
│ │ │ │ │ └── win32.py
│ │ │ │ ├── cpp.py
│ │ │ │ ├── dblite.py
│ │ │ │ └── exitfuncs.py
│ │ │ ├── libbacktrace/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README.md
│ │ │ │ └── backtrace/
│ │ │ │ ├── alloc.c
│ │ │ │ ├── backtrace-supported.h
│ │ │ │ ├── backtrace.c
│ │ │ │ ├── backtrace.h
│ │ │ │ ├── config.h
│ │ │ │ ├── dwarf.c
│ │ │ │ ├── elf.c
│ │ │ │ ├── fileline.c
│ │ │ │ ├── filenames.h
│ │ │ │ ├── internal.h
│ │ │ │ ├── macho.c
│ │ │ │ ├── mmap.c
│ │ │ │ ├── pecoff.c
│ │ │ │ ├── posix.c
│ │ │ │ ├── read.c
│ │ │ │ ├── sort.c
│ │ │ │ ├── state.c
│ │ │ │ └── xcoff.c
│ │ │ ├── markupsafe/
│ │ │ │ ├── LICENSE.rst
│ │ │ │ └── markupsafe/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _compat.py
│ │ │ │ ├── _constants.py
│ │ │ │ └── _native.py
│ │ │ ├── pkg_resources/
│ │ │ │ └── pkg_resources/
│ │ │ │ ├── __init__.py
│ │ │ │ └── py31compat.py
│ │ │ ├── pkg_resources_27/
│ │ │ │ └── pkg_resources/
│ │ │ │ └── __init__.py
│ │ │ ├── tqdm/
│ │ │ │ ├── LICENCE
│ │ │ │ └── tqdm/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _main.py
│ │ │ │ ├── _monitor.py
│ │ │ │ ├── _tqdm.py
│ │ │ │ ├── _tqdm_notebook.py
│ │ │ │ ├── _tqdm_pandas.py
│ │ │ │ ├── _utils.py
│ │ │ │ ├── auto.py
│ │ │ │ ├── autonotebook.py
│ │ │ │ ├── dask.py
│ │ │ │ ├── notebook.py
│ │ │ │ ├── std.py
│ │ │ │ ├── tk.py
│ │ │ │ ├── utils.py
│ │ │ │ └── version.py
│ │ │ ├── wax_off/
│ │ │ │ ├── LICENSE
│ │ │ │ └── wax_off.py
│ │ │ ├── yaml/
│ │ │ │ ├── LICENSE
│ │ │ │ └── yaml/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── composer.py
│ │ │ │ ├── constructor.py
│ │ │ │ ├── cyaml.py
│ │ │ │ ├── dumper.py
│ │ │ │ ├── emitter.py
│ │ │ │ ├── error.py
│ │ │ │ ├── events.py
│ │ │ │ ├── loader.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── reader.py
│ │ │ │ ├── representer.py
│ │ │ │ ├── resolver.py
│ │ │ │ ├── scanner.py
│ │ │ │ ├── serializer.py
│ │ │ │ └── tokens.py
│ │ │ ├── yaml_27/
│ │ │ │ ├── LICENSE
│ │ │ │ └── yaml/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── composer.py
│ │ │ │ ├── constructor.py
│ │ │ │ ├── cyaml.py
│ │ │ │ ├── dumper.py
│ │ │ │ ├── emitter.py
│ │ │ │ ├── error.py
│ │ │ │ ├── events.py
│ │ │ │ ├── loader.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── reader.py
│ │ │ │ ├── representer.py
│ │ │ │ ├── resolver.py
│ │ │ │ ├── scanner.py
│ │ │ │ ├── serializer.py
│ │ │ │ └── tokens.py
│ │ │ ├── yaml_35/
│ │ │ │ ├── LICENSE
│ │ │ │ └── yaml/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── composer.py
│ │ │ │ ├── constructor.py
│ │ │ │ ├── cyaml.py
│ │ │ │ ├── dumper.py
│ │ │ │ ├── emitter.py
│ │ │ │ ├── error.py
│ │ │ │ ├── events.py
│ │ │ │ ├── loader.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── reader.py
│ │ │ │ ├── representer.py
│ │ │ │ ├── resolver.py
│ │ │ │ ├── scanner.py
│ │ │ │ ├── serializer.py
│ │ │ │ └── tokens.py
│ │ │ ├── zlib/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── crc32.c
│ │ │ │ ├── crc32.h
│ │ │ │ ├── zconf.h
│ │ │ │ ├── zlib.h
│ │ │ │ └── zutil.h
│ │ │ └── zstd/
│ │ │ ├── LICENSE.txt
│ │ │ ├── common/
│ │ │ │ ├── bitstream.h
│ │ │ │ ├── compiler.h
│ │ │ │ ├── cpu.h
│ │ │ │ ├── debug.h
│ │ │ │ ├── entropy_common.c
│ │ │ │ ├── error_private.c
│ │ │ │ ├── error_private.h
│ │ │ │ ├── fse.h
│ │ │ │ ├── fse_decompress.c
│ │ │ │ ├── huf.h
│ │ │ │ ├── mem.h
│ │ │ │ ├── xxhash.c
│ │ │ │ ├── xxhash.h
│ │ │ │ ├── zstd_common.c
│ │ │ │ ├── zstd_deps.h
│ │ │ │ ├── zstd_errors.h
│ │ │ │ └── zstd_internal.h
│ │ │ ├── decompress/
│ │ │ │ ├── huf_decompress.c
│ │ │ │ ├── zstd_ddict.c
│ │ │ │ ├── zstd_ddict.h
│ │ │ │ ├── zstd_decompress.c
│ │ │ │ ├── zstd_decompress_block.c
│ │ │ │ ├── zstd_decompress_block.h
│ │ │ │ └── zstd_decompress_internal.h
│ │ │ └── zstd.h
│ │ └── static_src/
│ │ ├── CompiledAsyncgenType.c
│ │ ├── CompiledCellType.c
│ │ ├── CompiledCodeHelpers.c
│ │ ├── CompiledCoroutineType.c
│ │ ├── CompiledFrameType.c
│ │ ├── CompiledFunctionType.c
│ │ ├── CompiledGeneratorType.c
│ │ ├── CompiledGeneratorTypeUncompiledIntegration.c
│ │ ├── CompiledMethodType.c
│ │ ├── HelpersAllocator.c
│ │ ├── HelpersAttributes.c
│ │ ├── HelpersBuiltin.c
│ │ ├── HelpersBuiltinTypeMethods.c
│ │ ├── HelpersBytes.c
│ │ ├── HelpersCalling.c
│ │ ├── HelpersCallingGenerated.c
│ │ ├── HelpersChecksumTools.c
│ │ ├── HelpersClasses.c
│ │ ├── HelpersComparisonEq.c
│ │ ├── HelpersComparisonEqUtils.c
│ │ ├── HelpersComparisonGe.c
│ │ ├── HelpersComparisonGt.c
│ │ ├── HelpersComparisonLe.c
│ │ ├── HelpersComparisonLt.c
│ │ ├── HelpersComparisonNe.c
│ │ ├── HelpersConstantsBlob.c
│ │ ├── HelpersDeepcopy.c
│ │ ├── HelpersDictionaries.c
│ │ ├── HelpersDictionariesGenerated.c
│ │ ├── HelpersDumpBacktraces.c
│ │ ├── HelpersEnvironmentVariables.c
│ │ ├── HelpersEnvironmentVariablesSystem.c
│ │ ├── HelpersExceptions.c
│ │ ├── HelpersFiles.c
│ │ ├── HelpersFilesystemPaths.c
│ │ ├── HelpersFloats.c
│ │ ├── HelpersHeapStorage.c
│ │ ├── HelpersImport.c
│ │ ├── HelpersImportHard.c
│ │ ├── HelpersJitSources.c
│ │ ├── HelpersLists.c
│ │ ├── HelpersListsGenerated.c
│ │ ├── HelpersMappings.c
│ │ ├── HelpersMatching.c
│ │ ├── HelpersOperationBinaryAdd.c
│ │ ├── HelpersOperationBinaryAddUtils.c
│ │ ├── HelpersOperationBinaryBitand.c
│ │ ├── HelpersOperationBinaryBitor.c
│ │ ├── HelpersOperationBinaryBitxor.c
│ │ ├── HelpersOperationBinaryDivmod.c
│ │ ├── HelpersOperationBinaryDivmodUtils.c
│ │ ├── HelpersOperationBinaryFloordiv.c
│ │ ├── HelpersOperationBinaryInplaceAdd.c
│ │ ├── HelpersOperationBinaryLshift.c
│ │ ├── HelpersOperationBinaryMatmult.c
│ │ ├── HelpersOperationBinaryMod.c
│ │ ├── HelpersOperationBinaryMult.c
│ │ ├── HelpersOperationBinaryMultUtils.c
│ │ ├── HelpersOperationBinaryOlddiv.c
│ │ ├── HelpersOperationBinaryPow.c
│ │ ├── HelpersOperationBinaryPowUtils.c
│ │ ├── HelpersOperationBinaryRshift.c
│ │ ├── HelpersOperationBinarySub.c
│ │ ├── HelpersOperationBinaryTruediv.c
│ │ ├── HelpersOperationInplaceAdd.c
│ │ ├── HelpersOperationInplaceAddUtils.c
│ │ ├── HelpersOperationInplaceBitand.c
│ │ ├── HelpersOperationInplaceBitor.c
│ │ ├── HelpersOperationInplaceBitxor.c
│ │ ├── HelpersOperationInplaceFloordiv.c
│ │ ├── HelpersOperationInplaceLshift.c
│ │ ├── HelpersOperationInplaceMatmult.c
│ │ ├── HelpersOperationInplaceMod.c
│ │ ├── HelpersOperationInplaceMult.c
│ │ ├── HelpersOperationInplaceOlddiv.c
│ │ ├── HelpersOperationInplacePow.c
│ │ ├── HelpersOperationInplaceRshift.c
│ │ ├── HelpersOperationInplaceSub.c
│ │ ├── HelpersOperationInplaceTruediv.c
│ │ ├── HelpersProfiling.c
│ │ ├── HelpersPythonPgo.c
│ │ ├── HelpersRaising.c
│ │ ├── HelpersSafeStrings.c
│ │ ├── HelpersSequences.c
│ │ ├── HelpersSlices.c
│ │ ├── HelpersStrings.c
│ │ ├── HelpersTuples.c
│ │ ├── HelpersTypes.c
│ │ ├── InspectPatcher.c
│ │ ├── MainProgram.c
│ │ ├── MetaPathBasedLoader.c
│ │ ├── MetaPathBasedLoaderImportlibMetadataDistribution.c
│ │ ├── MetaPathBasedLoaderResourceReader.c
│ │ ├── MetaPathBasedLoaderResourceReaderFiles.c
│ │ ├── OnefileBootstrap.c
│ │ └── OnefileSplashScreen.cpp
│ ├── code_generation/
│ │ ├── AsyncgenCodes.py
│ │ ├── AttributeCodes.py
│ │ ├── BinaryOperationHelperDefinitions.py
│ │ ├── BranchCodes.py
│ │ ├── BuiltinCodes.py
│ │ ├── CallCodes.py
│ │ ├── ClassCodes.py
│ │ ├── CodeGeneration.py
│ │ ├── CodeHelperSelection.py
│ │ ├── CodeHelpers.py
│ │ ├── CodeObjectCodes.py
│ │ ├── ComparisonCodes.py
│ │ ├── ComparisonHelperDefinitions.py
│ │ ├── ConditionalCodes.py
│ │ ├── ConstantCodes.py
│ │ ├── Contexts.py
│ │ ├── CoroutineCodes.py
│ │ ├── CtypesCodes.py
│ │ ├── DictCodes.py
│ │ ├── Emission.py
│ │ ├── ErrorCodes.py
│ │ ├── EvalCodes.py
│ │ ├── ExceptionCodes.py
│ │ ├── ExpressionCTypeSelectionHelpers.py
│ │ ├── ExpressionCodes.py
│ │ ├── FrameCodes.py
│ │ ├── FunctionCodes.py
│ │ ├── GeneratorCodes.py
│ │ ├── GlobalConstants.py
│ │ ├── GlobalsLocalsCodes.py
│ │ ├── IdCodes.py
│ │ ├── ImportCodes.py
│ │ ├── Indentation.py
│ │ ├── IndexCodes.py
│ │ ├── InjectCCodes.py
│ │ ├── IntegerCodes.py
│ │ ├── IteratorCodes.py
│ │ ├── LabelCodes.py
│ │ ├── LineNumberCodes.py
│ │ ├── ListCodes.py
│ │ ├── LoaderCodes.py
│ │ ├── LocalsDictCodes.py
│ │ ├── LoopCodes.py
│ │ ├── MatchCodes.py
│ │ ├── ModuleCodes.py
│ │ ├── Namify.py
│ │ ├── OperationCodes.py
│ │ ├── PackageResourceCodes.py
│ │ ├── PrintCodes.py
│ │ ├── PythonAPICodes.py
│ │ ├── RaisingCodes.py
│ │ ├── Reports.py
│ │ ├── ReturnCodes.py
│ │ ├── SetCodes.py
│ │ ├── SliceCodes.py
│ │ ├── StringCodes.py
│ │ ├── SubscriptCodes.py
│ │ ├── TensorflowCodes.py
│ │ ├── TryCodes.py
│ │ ├── TupleCodes.py
│ │ ├── VariableCodes.py
│ │ ├── VariableDeclarations.py
│ │ ├── YieldCodes.py
│ │ ├── __init__.py
│ │ ├── c_types/
│ │ │ ├── CTypeBases.py
│ │ │ ├── CTypeBooleans.py
│ │ │ ├── CTypeCFloats.py
│ │ │ ├── CTypeCLongs.py
│ │ │ ├── CTypeModuleDictVariables.py
│ │ │ ├── CTypeNuitkaBooleans.py
│ │ │ ├── CTypeNuitkaInts.py
│ │ │ ├── CTypeNuitkaVoids.py
│ │ │ ├── CTypePyObjectPointers.py
│ │ │ ├── CTypeVoids.py
│ │ │ └── __init__.py
│ │ ├── templates/
│ │ │ ├── CodeTemplatesAsyncgens.py
│ │ │ ├── CodeTemplatesConstants.py
│ │ │ ├── CodeTemplatesCoroutines.py
│ │ │ ├── CodeTemplatesExceptions.py
│ │ │ ├── CodeTemplatesFrames.py
│ │ │ ├── CodeTemplatesFunction.py
│ │ │ ├── CodeTemplatesGeneratorFunction.py
│ │ │ ├── CodeTemplatesIterators.py
│ │ │ ├── CodeTemplatesLoader.py
│ │ │ ├── CodeTemplatesModules.py
│ │ │ ├── CodeTemplatesVariables.py
│ │ │ ├── TemplateDebugWrapper.py
│ │ │ └── __init__.py
│ │ └── templates_c/
│ │ ├── CodeTemplateCallsMethodPositional.c.j2
│ │ ├── CodeTemplateCallsMixed.c.j2
│ │ ├── CodeTemplateCallsPositional.c.j2
│ │ ├── CodeTemplateCallsPositionalMethodDescr.c.j2
│ │ ├── CodeTemplateMakeListHinted.c.j2
│ │ ├── CodeTemplateMakeListSmall.c.j2
│ │ ├── HelperBuiltinMethodOperation.c.j2
│ │ ├── HelperDictionaryCopy.c.j2
│ │ ├── HelperImportHard.c.j2
│ │ ├── HelperLongTools.c.j2
│ │ ├── HelperObjectTools.c.j2
│ │ ├── HelperOperationBinary.c.j2
│ │ ├── HelperOperationComparison.c.j2
│ │ ├── HelperOperationComparisonBytes.c.j2
│ │ ├── HelperOperationComparisonFloat.c.j2
│ │ ├── HelperOperationComparisonInt.c.j2
│ │ ├── HelperOperationComparisonList.c.j2
│ │ ├── HelperOperationComparisonLong.c.j2
│ │ ├── HelperOperationComparisonStr.c.j2
│ │ ├── HelperOperationComparisonTuple.c.j2
│ │ ├── HelperOperationComparisonUnicode.c.j2
│ │ ├── HelperOperationInplace.c.j2
│ │ ├── HelperSlotsBinary.c.j2
│ │ ├── HelperSlotsBytes.c.j2
│ │ ├── HelperSlotsCommon.c.j2
│ │ ├── HelperSlotsFloat.c.j2
│ │ ├── HelperSlotsInt.c.j2
│ │ ├── HelperSlotsList.c.j2
│ │ ├── HelperSlotsLong.c.j2
│ │ ├── HelperSlotsSet.c.j2
│ │ ├── HelperSlotsStr.c.j2
│ │ ├── HelperSlotsTuple.c.j2
│ │ └── HelperSlotsUnicode.c.j2
│ ├── containers/
│ │ ├── Namedtuples.py
│ │ ├── OrderedDicts.py
│ │ ├── OrderedSets.py
│ │ ├── OrderedSetsFallback.py
│ │ └── __init__.py
│ ├── distutils/
│ │ ├── Build.py
│ │ ├── DistutilCommands.py
│ │ └── __init__.py
│ ├── finalizations/
│ │ ├── Finalization.py
│ │ ├── FinalizeMarkups.py
│ │ └── __init__.py
│ ├── freezer/
│ │ ├── DependsExe.py
│ │ ├── DllDependenciesCommon.py
│ │ ├── DllDependenciesMacOS.py
│ │ ├── DllDependenciesPosix.py
│ │ ├── DllDependenciesWin32.py
│ │ ├── ImportDetection.py
│ │ ├── IncludedDataFiles.py
│ │ ├── IncludedEntryPoints.py
│ │ ├── Onefile.py
│ │ ├── Standalone.py
│ │ └── __init__.py
│ ├── importing/
│ │ ├── IgnoreListing.py
│ │ ├── ImportCache.py
│ │ ├── ImportResolving.py
│ │ ├── Importing.py
│ │ ├── PreloadedPackages.py
│ │ ├── Recursion.py
│ │ ├── StandardLibrary.py
│ │ └── __init__.py
│ ├── nodes/
│ │ ├── AsyncgenNodes.py
│ │ ├── AttributeLookupNodes.py
│ │ ├── AttributeNodes.py
│ │ ├── AttributeNodesGenerated.py
│ │ ├── BuiltinAllNodes.py
│ │ ├── BuiltinAnyNodes.py
│ │ ├── BuiltinComplexNodes.py
│ │ ├── BuiltinDecodingNodes.py
│ │ ├── BuiltinDecoratorNodes.py
│ │ ├── BuiltinDictNodes.py
│ │ ├── BuiltinFormatNodes.py
│ │ ├── BuiltinHashNodes.py
│ │ ├── BuiltinInputNodes.py
│ │ ├── BuiltinIntegerNodes.py
│ │ ├── BuiltinIteratorNodes.py
│ │ ├── BuiltinLenNodes.py
│ │ ├── BuiltinNextNodes.py
│ │ ├── BuiltinOpenNodes.py
│ │ ├── BuiltinOperationNodeBasesGenerated.py
│ │ ├── BuiltinRangeNodes.py
│ │ ├── BuiltinRefNodes.py
│ │ ├── BuiltinSumNodes.py
│ │ ├── BuiltinTypeNodes.py
│ │ ├── BuiltinVarsNodes.py
│ │ ├── BytesNodes.py
│ │ ├── CallNodes.py
│ │ ├── Checkers.py
│ │ ├── ChildrenHavingMixins.py
│ │ ├── ClassNodes.py
│ │ ├── CodeObjectSpecs.py
│ │ ├── ComparisonNodes.py
│ │ ├── ConditionalNodes.py
│ │ ├── ConstantRefNodes.py
│ │ ├── ContainerMakingNodes.py
│ │ ├── ContainerOperationNodes.py
│ │ ├── CoroutineNodes.py
│ │ ├── CtypesNodes.py
│ │ ├── DictionaryNodes.py
│ │ ├── ExceptionNodes.py
│ │ ├── ExecEvalNodes.py
│ │ ├── ExpressionBases.py
│ │ ├── ExpressionBasesGenerated.py
│ │ ├── ExpressionShapeMixins.py
│ │ ├── FrameNodes.py
│ │ ├── FunctionAttributeNodes.py
│ │ ├── FunctionNodes.py
│ │ ├── FutureSpecs.py
│ │ ├── GeneratorNodes.py
│ │ ├── GlobalsLocalsNodes.py
│ │ ├── HardImportNodesGenerated.py
│ │ ├── ImportHardNodes.py
│ │ ├── ImportNodes.py
│ │ ├── IndicatorMixins.py
│ │ ├── InjectCNodes.py
│ │ ├── IterationHandles.py
│ │ ├── KeyValuePairNodes.py
│ │ ├── ListOperationNodes.py
│ │ ├── LocalsDictNodes.py
│ │ ├── LocalsScopes.py
│ │ ├── LoopNodes.py
│ │ ├── MatchNodes.py
│ │ ├── ModuleAttributeNodes.py
│ │ ├── ModuleNodes.py
│ │ ├── NodeBases.py
│ │ ├── NodeMakingHelpers.py
│ │ ├── NodeMetaClasses.py
│ │ ├── OperatorNodes.py
│ │ ├── OperatorNodesUnary.py
│ │ ├── OsSysNodes.py
│ │ ├── OutlineNodes.py
│ │ ├── PackageMetadataNodes.py
│ │ ├── PackageResourceNodes.py
│ │ ├── PrintNodes.py
│ │ ├── ReturnNodes.py
│ │ ├── SideEffectNodes.py
│ │ ├── SliceNodes.py
│ │ ├── StatementBasesGenerated.py
│ │ ├── StatementNodes.py
│ │ ├── StrNodes.py
│ │ ├── StringConcatenationNodes.py
│ │ ├── SubscriptNodes.py
│ │ ├── TensorflowNodes.py
│ │ ├── TryNodes.py
│ │ ├── TypeMatchNodes.py
│ │ ├── TypeNodes.py
│ │ ├── VariableAssignNodes.py
│ │ ├── VariableDelNodes.py
│ │ ├── VariableNameNodes.py
│ │ ├── VariableRefNodes.py
│ │ ├── VariableReleaseNodes.py
│ │ ├── YieldNodes.py
│ │ ├── __init__.py
│ │ └── shapes/
│ │ ├── BuiltinTypeShapes.py
│ │ ├── ControlFlowDescriptions.py
│ │ ├── ShapeMixins.py
│ │ ├── StandardShapes.py
│ │ └── __init__.py
│ ├── optimizations/
│ │ ├── BytecodeDemotion.py
│ │ ├── FunctionInlining.py
│ │ ├── Graphs.py
│ │ ├── Optimization.py
│ │ ├── OptimizeBuiltinCalls.py
│ │ ├── Tags.py
│ │ ├── TraceCollections.py
│ │ ├── ValueTraces.py
│ │ └── __init__.py
│ ├── pgo/
│ │ ├── PGO.py
│ │ └── __init__.py
│ ├── plugins/
│ │ ├── PluginBase.py
│ │ ├── Plugins.py
│ │ ├── __init__.py
│ │ └── standard/
│ │ ├── AntiBloatPlugin.py
│ │ ├── ConsiderPyLintAnnotationsPlugin.py
│ │ ├── DataFilesPlugin.py
│ │ ├── DelvewheelPlugin.py
│ │ ├── DillPlugin/
│ │ │ ├── DillPlugin.c
│ │ │ └── dill-postLoad.py
│ │ ├── DillPlugin.py
│ │ ├── DllFilesPlugin.py
│ │ ├── EnumPlugin.py
│ │ ├── EventletPlugin.py
│ │ ├── GeventPlugin.py
│ │ ├── GiPlugin.py
│ │ ├── GlfwPlugin.py
│ │ ├── ImplicitImports.py
│ │ ├── KivyPlugin.py
│ │ ├── MatplotlibPlugin.py
│ │ ├── MultiprocessingPlugin.py
│ │ ├── NumpyPlugin.py
│ │ ├── OptionsNannyPlugin.py
│ │ ├── PbrPlugin.py
│ │ ├── PkgResourcesPlugin.py
│ │ ├── PmwPlugin.py
│ │ ├── PySidePyQtPlugin.py
│ │ ├── PywebViewPlugin.py
│ │ ├── TensorflowPlugin.py
│ │ ├── TkinterPlugin.py
│ │ ├── TorchPlugin.py
│ │ ├── TransformersPlugin.py
│ │ ├── TrioPlugin.py
│ │ ├── UpxPlugin.py
│ │ ├── __init__.py
│ │ ├── standard.nuitka-package.config.yml
│ │ ├── stdlib2.nuitka-package.config.yml
│ │ └── stdlib3.nuitka-package.config.yml
│ ├── reports/
│ │ ├── CompilationReportReader.py
│ │ ├── LicenseReport.rst.j2
│ │ ├── Reports.py
│ │ └── __init__.py
│ ├── specs/
│ │ ├── BuiltinBytesOperationSpecs.py
│ │ ├── BuiltinDictOperationSpecs.py
│ │ ├── BuiltinListOperationSpecs.py
│ │ ├── BuiltinParameterSpecs.py
│ │ ├── BuiltinStrOperationSpecs.py
│ │ ├── BuiltinTypeOperationSpecs.py
│ │ ├── BuiltinUnicodeOperationSpecs.py
│ │ ├── HardImportSpecs.py
│ │ ├── ParameterSpecs.py
│ │ └── __init__.py
│ ├── tools/
│ │ ├── Basics.py
│ │ ├── __init__.py
│ │ ├── commercial/
│ │ │ └── __init__.py
│ │ ├── data_composer/
│ │ │ ├── DataComposer.py
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── environments/
│ │ │ ├── CreateEnvironment.py
│ │ │ ├── Virtualenv.py
│ │ │ └── __init__.py
│ │ ├── general/
│ │ │ ├── __init__.py
│ │ │ ├── dll_report/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ └── find_module/
│ │ │ ├── FindModuleCode.py
│ │ │ └── __init__.py
│ │ ├── onefile_compressor/
│ │ │ ├── OnefileCompressor.py
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── podman/
│ │ │ ├── Podman.py
│ │ │ ├── __init__.py
│ │ │ ├── __main__.py
│ │ │ └── containers/
│ │ │ ├── CI.containerfile
│ │ │ └── Python-Minor-Versions.containerfile
│ │ ├── profiler/
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── quality/
│ │ │ ├── Git.py
│ │ │ ├── ScanSources.py
│ │ │ ├── __init__.py
│ │ │ ├── apidoc/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── auto_format/
│ │ │ │ ├── AutoFormat.py
│ │ │ │ ├── YamlFormatter.py
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── codespell/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── pylint/
│ │ │ │ ├── PyLint.py
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── restlint/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ └── yamllint/
│ │ │ ├── YamlChecker.py
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── release/
│ │ │ ├── Debian.py
│ │ │ ├── Documentation.py
│ │ │ ├── Release.py
│ │ │ ├── __init__.py
│ │ │ ├── bump/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── debian/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── debian_mentors/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── osc_check/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── osc_upload/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── pypi/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── rpm/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── __main__.py
│ │ │ │ └── nuitka.spec
│ │ │ └── sync_doc/
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── scanning/
│ │ │ ├── DisplayPackageDLLs.py
│ │ │ ├── DisplayPackageData.py
│ │ │ └── __init__.py
│ │ ├── specialize/
│ │ │ ├── CTypeDescriptions.py
│ │ │ ├── Common.py
│ │ │ ├── SpecializeC.py
│ │ │ ├── SpecializePython.py
│ │ │ ├── __init__.py
│ │ │ └── templates_python/
│ │ │ ├── AttributeNodeFixed.py.j2
│ │ │ ├── BuiltinOperationNodeBases.py.j2
│ │ │ ├── ChildrenHavingMixin.py.j2
│ │ │ ├── HardImportCallNode.py.j2
│ │ │ └── HardImportReferenceNode.py.j2
│ │ ├── testing/
│ │ │ ├── Common.py
│ │ │ ├── Constructs.py
│ │ │ ├── OutputComparison.py
│ │ │ ├── Pythons.py
│ │ │ ├── RuntimeTracing.py
│ │ │ ├── SearchModes.py
│ │ │ ├── Valgrind.py
│ │ │ ├── __init__.py
│ │ │ ├── check_reference_counts/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── compare_with_cpython/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── find_sxs_modules/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── measure_construct_performance/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ └── run_nuitka_tests/
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ └── watch/
│ │ ├── GitHub.py
│ │ ├── __init__.py
│ │ └── __main__.py
│ ├── tree/
│ │ ├── Building.py
│ │ ├── ComplexCallHelperFunctions.py
│ │ ├── Extractions.py
│ │ ├── InternalModule.py
│ │ ├── Operations.py
│ │ ├── ReformulationAssertStatements.py
│ │ ├── ReformulationAssignmentStatements.py
│ │ ├── ReformulationBooleanExpressions.py
│ │ ├── ReformulationCallExpressions.py
│ │ ├── ReformulationClasses.py
│ │ ├── ReformulationClasses3.py
│ │ ├── ReformulationComparisonExpressions.py
│ │ ├── ReformulationContractionExpressions.py
│ │ ├── ReformulationDictionaryCreation.py
│ │ ├── ReformulationExecStatements.py
│ │ ├── ReformulationForLoopStatements.py
│ │ ├── ReformulationFunctionStatements.py
│ │ ├── ReformulationImportStatements.py
│ │ ├── ReformulationLambdaExpressions.py
│ │ ├── ReformulationMatchStatements.py
│ │ ├── ReformulationMultidist.py
│ │ ├── ReformulationNamespacePackages.py
│ │ ├── ReformulationPrintStatements.py
│ │ ├── ReformulationSequenceCreation.py
│ │ ├── ReformulationSubscriptExpressions.py
│ │ ├── ReformulationTryExceptStatements.py
│ │ ├── ReformulationTryFinallyStatements.py
│ │ ├── ReformulationWhileLoopStatements.py
│ │ ├── ReformulationWithStatements.py
│ │ ├── ReformulationYieldExpressions.py
│ │ ├── SourceHandling.py
│ │ ├── SyntaxErrors.py
│ │ ├── TreeHelpers.py
│ │ ├── VariableClosure.py
│ │ └── __init__.py
│ └── utils/
│ ├── AppDirs.py
│ ├── CStrings.py
│ ├── CommandLineOptions.py
│ ├── Distributions.py
│ ├── Download.py
│ ├── Execution.py
│ ├── FileOperations.py
│ ├── Hashing.py
│ ├── Images.py
│ ├── Importing.py
│ ├── InstalledPythons.py
│ ├── InstanceCounters.py
│ ├── Jinja2.py
│ ├── Json.py
│ ├── MacOSApp.py
│ ├── MemoryUsage.py
│ ├── ModuleNames.py
│ ├── ReExecute.py
│ ├── Rest.py
│ ├── SharedLibraries.py
│ ├── Shebang.py
│ ├── Signing.py
│ ├── SlotMetaClasses.py
│ ├── StaticLibraries.py
│ ├── ThreadedExecutor.py
│ ├── Timing.py
│ ├── Utils.py
│ ├── WindowsFileUsage.py
│ ├── WindowsResources.py
│ ├── Yaml.py
│ └── __init__.py
├── pyproject.toml
├── requirements-devel.txt
├── requirements.txt
├── rpm/
│ ├── check-osc-status.py
│ ├── make-osc-upload.py
│ ├── nuitka-rpmlintrc
│ └── nuitka.spec
├── setup.py
└── tests/
├── PyPI-pytest/
│ ├── README.rst
│ ├── packages.json
│ └── run_all.py
├── README.txt
├── basics/
│ ├── AssertsTest.py
│ ├── AssignmentsTest.py
│ ├── AssignmentsTest32.py
│ ├── BranchingTest.py
│ ├── BuiltinOverload.py
│ ├── BuiltinSuperTest.py
│ ├── BuiltinsTest.py
│ ├── ClassMinimalTest.py
│ ├── ClassesTest.py
│ ├── ClassesTest32.py
│ ├── ClassesTest34.py
│ ├── ComparisonChainsTest.py
│ ├── ConstantsTest.py
│ ├── ConstantsTest27.py
│ ├── DecoratorsTest.py
│ ├── DefaultParametersTest.py
│ ├── DoubleDeletionsTest.py
│ ├── EmptyModuleTest.py
│ ├── ExceptionRaisingTest.py
│ ├── ExceptionRaisingTest32.py
│ ├── ExceptionRaisingTest33.py
│ ├── ExecEvalTest.py
│ ├── ExtremeClosureTest.py
│ ├── FunctionObjectsTest.py
│ ├── FunctionsTest.py
│ ├── FunctionsTest32.py
│ ├── FunctionsTest_2.py
│ ├── FutureTest32.py
│ ├── GeneratorExpressionsTest.py
│ ├── GeneratorExpressionsTest_37.py
│ ├── GlobalStatementTest.py
│ ├── HelloWorldTest_2.py
│ ├── ImportingTest.py
│ ├── InplaceOperationsTest.py
│ ├── InspectionTest.py
│ ├── InspectionTest_35.py
│ ├── InspectionTest_36.py
│ ├── LambdasTest.py
│ ├── LateClosureAssignmentTest.py
│ ├── ListContractionsTest.py
│ ├── LoopingTest.py
│ ├── MainProgramsTest.py
│ ├── ModuleAttributesTest.py
│ ├── OperatorsTest.py
│ ├── OrderChecksTest.py
│ ├── OrderChecksTest27.py
│ ├── OverflowFunctionsTest_2.py
│ ├── ParameterErrorsTest.py
│ ├── ParameterErrorsTest32.py
│ ├── PrintFutureTest.py
│ ├── PrintingTest_2.py
│ ├── README.rst
│ ├── RecursionTest.py
│ ├── ReferencingTest.py
│ ├── ReferencingTest27.py
│ ├── ReferencingTest33.py
│ ├── ReferencingTest35.py
│ ├── ReferencingTest36.py
│ ├── ReferencingTest_2.py
│ ├── SlotsTest.py
│ ├── ThreadedGeneratorsTest.py
│ ├── TrickAssignmentsTest32.py
│ ├── TrickAssignmentsTest35.py
│ ├── TrickAssignmentsTest_2.py
│ ├── TryContinueFinallyTest.py
│ ├── TryExceptContinueTest.py
│ ├── TryExceptFinallyTest.py
│ ├── TryExceptFramesTest.py
│ ├── TryReturnFinallyTest.py
│ ├── TryYieldFinallyTest.py
│ ├── UnicodeTest.py
│ ├── UnpackingTest35.py
│ ├── VarargsTest.py
│ ├── WithStatementsTest.py
│ ├── YieldFromTest33.py
│ ├── run_all.py
│ └── run_xml.py
├── benchmarks/
│ ├── binary-trees.py
│ ├── comparisons/
│ │ └── GeneratorFunctionVsGeneratorExpression.py
│ ├── constructs/
│ │ ├── BuiltinSumWithGenerator.py
│ │ ├── BuiltinSumWithList.py
│ │ ├── BuiltinSumWithTuple.py
│ │ ├── CallCompiledClassCreationPosArgsConstant6.py
│ │ ├── CallCompiledFunctionKwArgsConstant.py
│ │ ├── CallCompiledFunctionKwArgsVariable.py
│ │ ├── CallCompiledFunctionKwArgsVariableStarDict.py
│ │ ├── CallCompiledFunctionPosArgsConstant.py
│ │ ├── CallCompiledFunctionPosArgsDefaults.py
│ │ ├── CallCompiledFunctionPosArgsMutable.py
│ │ ├── CallCompiledFunctionPosArgsVariable.py
│ │ ├── CallCompiledFunctionPosKwArgsVariable.py
│ │ ├── CallCompiledInstanceMethodNoArgs_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsConstant1_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsConstant6_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsDefaults_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsVariable_27.py
│ │ ├── CallCompiledObjectMethodNoArgs.py
│ │ ├── CallCompiledObjectMethodPosArgsConstant1.py
│ │ ├── CallCompiledObjectMethodPosArgsConstant6.py
│ │ ├── CallCompiledObjectMethodPosArgsDefaults.py
│ │ ├── CallCompiledObjectMethodPosArgsVariable.py
│ │ ├── CallLambdaExpressionDirectly.py
│ │ ├── CallUncompiledFunctionComplexArgs.py
│ │ ├── CallUncompiledFunctionPosArgs.py
│ │ ├── ClosureVariableAccess.py
│ │ ├── DictCreation.py
│ │ ├── FunctionCreationClosure.py
│ │ ├── FunctionCreationGeneratorClosure.py
│ │ ├── FunctionCreationGeneratorLocal.py
│ │ ├── FunctionCreationLocal.py
│ │ ├── FunctionEmpty.py
│ │ ├── FunctionRaise.py
│ │ ├── GeneratorExit.py
│ │ ├── GeneratorExpressionCreation.py
│ │ ├── GeneratorExpressionExit.py
│ │ ├── GeneratorExpressionUsage.py
│ │ ├── GeneratorUsage.py
│ │ ├── GlobalVariableAccess.py
│ │ ├── InplaceOperationFloatAdd.py
│ │ ├── InplaceOperationInstanceStringAdd.py
│ │ ├── InplaceOperationIntegerAdd.py
│ │ ├── InplaceOperationIntegerMul.py
│ │ ├── InplaceOperationListAdd.py
│ │ ├── InplaceOperationLongAdd_27.py
│ │ ├── InplaceOperationStringAdd.py
│ │ ├── InplaceOperationTupleAdd.py
│ │ ├── InplaceOperationUnicodeAdd_27.py
│ │ ├── ListContraction.py
│ │ ├── ListCreation.py
│ │ ├── ListCreationConstant.py
│ │ ├── LocalVariableAccess.py
│ │ ├── LocalVariableDeletion.py
│ │ ├── LoopSmallRange.py
│ │ ├── LoopSmallXrange.py
│ │ ├── NumpyArrayConstruction.py
│ │ ├── OperationAttributeLookup.py
│ │ ├── OperationFloatAdd.py
│ │ ├── OperationIntegerAdd.py
│ │ ├── OperationIntegerMul.py
│ │ ├── OperationIntegerPower.py
│ │ ├── OperationListIntegerIndexLookup.py
│ │ ├── RichComparisonConditionStrings.py
│ │ ├── RichComparisonStrings.py
│ │ ├── SetCreation.py
│ │ ├── TupleCreation.py
│ │ └── UnpackIterator.py
│ ├── mandelbrot.py
│ ├── pybench/
│ │ ├── Arithmetic.py
│ │ ├── Calls.py
│ │ ├── CommandLine.py
│ │ ├── Constructs.py
│ │ ├── Dict.py
│ │ ├── Exceptions.py
│ │ ├── Imports.py
│ │ ├── Instances.py
│ │ ├── LICENSE
│ │ ├── Lists.py
│ │ ├── Lookups.py
│ │ ├── NewInstances.py
│ │ ├── Numbers.py
│ │ ├── README
│ │ ├── Setup.py
│ │ ├── Strings.py
│ │ ├── Tuples.py
│ │ ├── Unicode.py
│ │ ├── With.py
│ │ ├── clockres.py
│ │ ├── package/
│ │ │ ├── __init__.py
│ │ │ └── submodule.py
│ │ ├── pybench.py
│ │ └── systimes.py
│ ├── pystone.py
│ ├── pystone3.py
│ └── recipe-577834-1.py
├── codegen-analysis/
│ └── README.txt
├── distutils/
│ ├── .gitignore
│ ├── example_1_pyproject/
│ │ ├── data_files/
│ │ │ └── some_datafile.txt
│ │ ├── example1_package/
│ │ │ ├── __init__.py
│ │ │ └── data/
│ │ │ └── package_data.txt
│ │ ├── pyproject.cpython.toml
│ │ ├── pyproject.nuitka.toml
│ │ ├── runner
│ │ └── setup.cfg
│ ├── example_1_setuptools/
│ │ ├── data_files/
│ │ │ └── some_datafile.txt
│ │ ├── example1_package/
│ │ │ ├── __init__.py
│ │ │ └── data/
│ │ │ └── package_data.txt
│ │ ├── runner
│ │ └── setup.py
│ ├── example_2_pyproject/
│ │ ├── pyproject.cpython.toml
│ │ ├── pyproject.nuitka.toml
│ │ └── src/
│ │ └── main.py
│ ├── example_2_setuptools/
│ │ ├── package1/
│ │ │ ├── __init__.py
│ │ │ ├── main.py
│ │ │ ├── module1.py
│ │ │ ├── module2.py
│ │ │ ├── subpackage1/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── data.txt
│ │ │ │ └── submodule11.py
│ │ │ └── subpackage2/
│ │ │ ├── __init__.py
│ │ │ └── submodule21.py
│ │ └── setup.py
│ ├── example_3_pyproject/
│ │ ├── pyproject.cpython.toml
│ │ ├── pyproject.nuitka.toml
│ │ └── src/
│ │ ├── runner
│ │ └── some_namespace/
│ │ └── some_package/
│ │ ├── __init__.py
│ │ └── sub_package/
│ │ └── __init__.py
│ ├── example_3_setuptools32/
│ │ ├── outer/
│ │ │ └── inner/
│ │ │ ├── __init__.py
│ │ │ └── main.py
│ │ └── setup.py
│ ├── example_4_setuptools_cfg/
│ │ ├── data_files/
│ │ │ └── some_datafile.txt
│ │ ├── example1_package/
│ │ │ ├── __init__.py
│ │ │ └── data/
│ │ │ └── package_data.txt
│ │ ├── runner
│ │ ├── setup.cfg
│ │ └── setup.py
│ ├── example_5_versioneer_setuptools32/
│ │ ├── runner
│ │ ├── setup.cfg
│ │ ├── setup.py
│ │ ├── some_package/
│ │ │ ├── __init__.py
│ │ │ └── _version.py
│ │ └── versioneer.py
│ ├── example_multiple_packages/
│ │ ├── main_module.py
│ │ ├── other_package/
│ │ │ └── __init__.py
│ │ ├── other_package_a/
│ │ │ └── __init__.py
│ │ ├── runner
│ │ ├── setup.py
│ │ ├── some_package/
│ │ │ └── __init__.py
│ │ ├── some_package_a/
│ │ │ └── __init__.py
│ │ └── some_package_b/
│ │ └── __init__.py
│ ├── example_nested_namespaces32/
│ │ ├── a/
│ │ │ └── b/
│ │ │ └── pkg/
│ │ │ └── __init__.py
│ │ └── setup.py
│ ├── example_package_and_module/
│ │ ├── runner
│ │ ├── setup.py
│ │ ├── some_module.py
│ │ └── some_package/
│ │ └── __init__.py
│ ├── example_pymodules_only/
│ │ ├── py_modules_only.py
│ │ ├── runner
│ │ └── setup.py
│ └── run_all.py
├── generated/
│ ├── BigConstantsTest.py.j2
│ ├── BytesMethodsTest.py.j2
│ ├── BytesMethodsTest32.py.j2
│ ├── DictMethodsTest.py.j2
│ ├── InplaceTest.py.j2
│ ├── OperationsTest.py.j2
│ ├── StrMethodsTest.py.j2
│ └── run_all.py
├── library/
│ ├── check_yaml_anti_bloat_modules.py
│ ├── compile_extension_modules.py
│ └── compile_python_modules.py
├── onefile/
│ ├── HelloWorldTest.py
│ ├── KeyboardInterruptTest.py
│ └── run_all.py
├── optimizations/
│ ├── ArgumentTypes.py
│ ├── AttributesTest.py
│ ├── CallsTest.py
│ ├── ConditionsTest.py
│ ├── DecodingOperationsTest.py
│ ├── FormatStringsTest36.py
│ ├── HardImportsTest.py
│ ├── HardImportsTest_2.py
│ ├── Iterations.py
│ ├── LenTest.py
│ ├── MatchingTest310.py
│ ├── OperationsTest.py
│ ├── SubscriptsTest.py
│ └── run_all.py
├── packages/
│ ├── package_data_files_embedding/
│ │ ├── PackageDataFilesEmbedding.py
│ │ ├── __init__.py
│ │ ├── lala.txt
│ │ └── sub_dir/
│ │ └── lulu.txt
│ ├── package_import_success_after_failure/
│ │ ├── PackageImportSuccessAfterFailure.py
│ │ └── variable_package/
│ │ ├── SomeModule.py
│ │ └── __init__.py
│ ├── run_all.py
│ ├── sub_package/
│ │ └── kitty/
│ │ ├── __init__.py
│ │ ├── bigkitty.py
│ │ ├── smallkitty.py
│ │ └── speak/
│ │ ├── __init__.py
│ │ ├── hello.py
│ │ ├── miau.py
│ │ └── purr.py
│ └── top_level_attributes_3/
│ └── some_package/
│ ├── __init__.py
│ └── some_module.py
├── pgo/
│ ├── run_all.py
│ └── unused_module/
│ ├── ImportedButMaybeNotUsed.py
│ └── UnusedModuleMain.py
├── plugins/
│ ├── README.rst
│ ├── code_signing/
│ │ └── CodeSigningMain.py
│ ├── data_files/
│ │ ├── DataFilesMain.py
│ │ ├── data_files_package/
│ │ │ ├── __init__.py
│ │ │ ├── lala.txt
│ │ │ └── sub_dir/
│ │ │ └── lulu.txt
│ │ └── test_case.nuitka-package.config.yml
│ ├── parameters/
│ │ ├── ParametersMain.py
│ │ └── parameter-using-plugin.py
│ └── run_all.py
├── programs/
│ ├── absolute_import/
│ │ ├── AbsoluteImportMain.py
│ │ └── foobar/
│ │ ├── __init__.py
│ │ ├── foobar.py
│ │ ├── local.py
│ │ └── util.py
│ ├── case_imports1/
│ │ ├── CasedImportingMain.py
│ │ ├── path1/
│ │ │ ├── Some_Module.py
│ │ │ └── Some_Package/
│ │ │ └── __init__.py
│ │ └── path2/
│ │ ├── some_module.py
│ │ └── some_package/
│ │ └── __init__.py
│ ├── case_imports2/
│ │ ├── CasedImportingMain.py
│ │ ├── path1/
│ │ │ ├── some_module.py
│ │ │ └── some_package/
│ │ │ └── __init__.py
│ │ └── path2/
│ │ ├── Some_Module.py
│ │ └── Some_Package/
│ │ └── __init__.py
│ ├── case_imports3/
│ │ ├── CasedImportingMain.py
│ │ ├── path1/
│ │ │ ├── Some_Module.py
│ │ │ └── Some_Package/
│ │ │ └── __init__.py
│ │ └── path2/
│ │ ├── Some_Module.py
│ │ └── Some_Package/
│ │ └── __init__.py
│ ├── cyclic_imports/
│ │ ├── CyclicImportsMain.py
│ │ └── cyclic_importing_package/
│ │ ├── Child1.py
│ │ ├── Child2.py
│ │ └── __init__.py
│ ├── dash_import/
│ │ ├── DashImportMain.py
│ │ ├── dash-module.py
│ │ └── plus+module.py
│ ├── dash_main/
│ │ └── Dash-Main.py
│ ├── deep/
│ │ ├── DeepProgramMain.py
│ │ └── some_package/
│ │ ├── DeepBrother.py
│ │ ├── DeepChild.py
│ │ ├── __init__.py
│ │ └── deep_package/
│ │ ├── DeepDeepChild.py
│ │ └── __init__.py
│ ├── dunderinit_imports/
│ │ ├── DunderInitImportsMain.py
│ │ └── package/
│ │ ├── SubModule.py
│ │ └── __init__.py
│ ├── import_variants/
│ │ ├── ImportVariationsMain.py
│ │ └── some_package/
│ │ ├── Child1.py
│ │ ├── Child2.py
│ │ ├── Child3.py
│ │ └── __init__.py
│ ├── main_raises/
│ │ ├── ErrorMain.py
│ │ └── ErrorRaising.py
│ ├── main_raises2/
│ │ ├── ErrorInFunctionMain.py
│ │ └── ErrorRaising.py
│ ├── module_attributes/
│ │ ├── ModuleAttributesMain.py
│ │ └── package_level1/
│ │ ├── Nearby1.py
│ │ ├── __init__.py
│ │ └── package_level2/
│ │ ├── Nearby2.py
│ │ ├── __init__.py
│ │ └── package_level3/
│ │ ├── Nearby3.py
│ │ └── __init__.py
│ ├── module_exits/
│ │ ├── ErrorExitingModule.py
│ │ └── Main.py
│ ├── module_object_replacing/
│ │ ├── ModuleObjectReplacingMain.py
│ │ └── SelfReplacingModule.py
│ ├── multiprocessing_using/
│ │ ├── MultiprocessingUsingMain.py
│ │ └── foo/
│ │ ├── __init__.py
│ │ ├── __main__.py
│ │ └── entry.py
│ ├── named_imports/
│ │ ├── NamedImportsMain.py
│ │ └── some_package/
│ │ ├── SomeModule.py
│ │ ├── __init__.py
│ │ └── sub_package/
│ │ └── SomeModule.py
│ ├── package_code/
│ │ ├── PackageInitCodeMain.py
│ │ └── some_package/
│ │ ├── SomeModule.py
│ │ └── __init__.py
│ ├── package_contains_main/
│ │ ├── PackageContainsMain.py
│ │ ├── __init__.py
│ │ └── local.py
│ ├── package_init_import/
│ │ ├── PackageInitImportMain.py
│ │ └── some_package/
│ │ ├── PackageLocal.py
│ │ └── __init__.py
│ ├── package_init_issue/
│ │ ├── PackageInitIssueMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ └── child_package/
│ │ ├── SomeModule.py
│ │ └── __init__.py
│ ├── package_missing_init/
│ │ ├── PackageMissingInitMain.py
│ │ └── some_package/
│ │ ├── some_module.py
│ │ └── sub_package/
│ │ └── some_sub_module.py
│ ├── package_module_collision/
│ │ ├── PackageAndModuleNamedSameMain.py
│ │ ├── Something/
│ │ │ └── __init__.py
│ │ └── something.py
│ ├── package_overload/
│ │ ├── Main.py
│ │ └── foo/
│ │ ├── __init__.py
│ │ ├── bar.py
│ │ └── bar2.py
│ ├── package_prevents_submodule/
│ │ ├── PackagePreventsSubmoduleMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ └── some_module.py
│ ├── package_program/
│ │ └── PackageAsMain/
│ │ ├── __init__.py
│ │ └── __main__.py
│ ├── pkgutil_itermodules/
│ │ ├── PkgUtilIterModulesMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ ├── sub_package1/
│ │ │ ├── SomeModuleC.py
│ │ │ ├── SomeModuleD.py
│ │ │ └── __init__.py
│ │ └── sub_package2/
│ │ ├── SomeModuleA.py
│ │ ├── SomeModuleB.py
│ │ └── __init__.py
│ ├── pkgutil_usage/
│ │ ├── PkgUtilUsageMain.py
│ │ └── package/
│ │ ├── DATA_FILE.txt
│ │ ├── DATA_FILE2.txt
│ │ ├── DATA_FILE3.txt
│ │ └── __init__.py
│ ├── plugin_import/
│ │ ├── PluginImportMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ ├── data/
│ │ │ └── .gitignore
│ │ └── some_module.py
│ ├── reimport_main_dynamic/
│ │ └── ImportItselfDynamicMain.py
│ ├── reimport_main_static/
│ │ └── ImportItselfStaticMain.py
│ ├── relative_import/
│ │ ├── RelativeImportMain.py
│ │ └── dircache.py
│ ├── resource_reader37/
│ │ ├── ResourceReaderMain.py
│ │ └── some_package/
│ │ ├── DATA_FILE.txt
│ │ └── __init__.py
│ ├── run_all.py
│ ├── stdlib_overload/
│ │ ├── StdlibOverloadMain.py
│ │ ├── pyexpat.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ ├── normal_importing.py
│ │ ├── pyexpat.py
│ │ └── star_importing.py
│ ├── syntax_errors/
│ │ ├── IndentationErroring.py
│ │ ├── SyntaxErroring.py
│ │ └── SyntaxErrorsMain.py
│ ├── unicode_bom/
│ │ ├── UnicodeBomMain.py
│ │ └── unicode_bom.py
│ └── with space/
│ └── Space Main.py
├── reflected/
│ └── compile_itself.py
├── run-tests
├── standalone/
│ ├── BrotliUsing.py
│ ├── CtypesUsing.py
│ ├── DateutilsUsing.py
│ ├── FlaskUsing.py
│ ├── GiUsing.py
│ ├── GlfwUsing.py
│ ├── GtkUsing.py
│ ├── HexEncodingTest_2.py
│ ├── IdnaUsing.py
│ ├── LxmlUsing.py
│ ├── MatplotlibUsing.py
│ ├── MetadataPackagesUsing.py
│ ├── NumpyUsing.py
│ ├── OpenGLUsing.py
│ ├── PandasUsing.py
│ ├── PasslibUsing.py
│ ├── PendulumUsing.py
│ ├── PkgResourcesRequiresUsing.py
│ ├── PmwUsing.py
│ ├── PyQt5Plugins.py
│ ├── PyQt5SSLSupport.py
│ ├── PyQt5Using.py
│ ├── PyQt6Plugins.py
│ ├── PyQt6Using.py
│ ├── PySide2Using.py
│ ├── PySide6Plugins.py
│ ├── PySide6Using.py
│ ├── RsaUsing.py
│ ├── SetuptoolsUsing.py
│ ├── ShlibUsing.py
│ ├── SocketUsing.py
│ ├── TkInterUsing.py
│ ├── Urllib3Using.py
│ ├── Win32ComUsing.py
│ ├── run_all.py
│ └── zip_importer/
│ └── ZipImporterMain.py
├── syntax/
│ ├── AsyncgenReturn36.py
│ ├── AwaitInModule36.py
│ ├── BreakWithoutLoop.py
│ ├── ClassReturn.py
│ ├── ClosureDel_2.py
│ ├── ContinueWithoutLoop.py
│ ├── DuplicateArgument.py
│ ├── ExecWithNesting_2.py
│ ├── FutureBraces.py
│ ├── FutureUnknown.py
│ ├── GeneratorExpressions38.py
│ ├── GeneratorReturn_2.py
│ ├── GlobalForParameter.py
│ ├── Importing32.py
│ ├── IndentationError.py
│ ├── LateFutureImport.py
│ ├── MisplacedFutureImport.py
│ ├── ModuleReturn.py
│ ├── NonAsciiWithoutEncoding_2.py
│ ├── NonlocalForParameter32.py
│ ├── NonlocalNotFound32.py
│ ├── StarImportExtra.py
│ ├── SyntaxError.py
│ ├── TryExceptAllNotLast.py
│ ├── TryFinallyContinue_37.py
│ ├── UnpackNoTuple.py
│ ├── UnpackTwoStars32.py
│ ├── YieldFromInModule.py
│ ├── YieldInAsync35.py
│ ├── YieldInGenexp38.py
│ ├── YieldInModule.py
│ └── run_all.py
├── test-runners/
│ ├── run_all.py
│ └── subject/
│ └── package/
│ ├── Something.py
│ ├── __init__.py
│ ├── sub_package1/
│ │ ├── SubSomething1.py
│ │ ├── __init__.py
│ │ └── tests/
│ │ ├── __init__.py
│ │ └── test_subsomething1.py
│ ├── sub_package2/
│ │ ├── SubSomething2.py
│ │ ├── __init__.py
│ │ └── tests/
│ │ ├── __init__.py
│ │ └── test_subsomething2.py
│ └── tests/
│ ├── __init__.py
│ └── test_something.py
└── type_inference/
├── Test1.py
├── Test2.py
├── Test3.py
└── Test4.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
root = true
[*.{py,c,cpp,h,rst,md,yml}]
trim_trailing_whitespace = true
insert_final_newline = true
indent_style = space
[*.{py,c,cpp,h}]
indent_size = 4
[*.yml]
indent_size = 2
================================================
FILE: .gitattributes
================================================
* -text
================================================
FILE: .githooks/pre-commit
================================================
#!/bin/sh
# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
#
# An example hook script to verify what is about to be committed.
# Called by "git commit" with no arguments. The hook should
# exit with non-zero status after issuing an appropriate message if
# it wants to stop the commit.
#
# To enable this hook, rename this file to "pre-commit".
if git rev-parse --verify HEAD >/dev/null 2>&1; then
against=HEAD
else
# Initial commit: diff against an empty tree object
against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi
# Redirect output to stderr.
exec 1>&2
files=$(git diff --cached --name-only $against)
if [ -z "$files" ]; then
exit 0
fi
# Autoformat the files.
if [ "$COMMIT_UNCHECKED" != "1" ]; then
exec ./bin/autoformat-nuitka-source --from-commit
fi
# 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.
================================================
FILE: .github/FUNDING.yml
================================================
custom: ['https://nuitka.net/pages/donations.html']
================================================
FILE: .github/ISSUE_TEMPLATE.md
================================================
Before submitting an Issue, please review the
[Issue Guidelines](https://github.com/Nuitka/Nuitka/blob/develop/CONTRIBUTING.md#submitting-an-issue).
- Please check whether the bug was already reported or fixed.
- Please check out if the develop version of Nuitka works better for you.
Download source, packages [from here](https://nuitka.net/doc/download.html) where you will also
find instructions how to do it via pip or git.
If you want to post a problem/bug, to help us understand and resolve your issue please check that
you have provided at least the information below, and discard up to here:
- Nuitka version, full Python version, flavor, OS, etc. as output by *this exact* command.
> python -m nuitka --version
If you are not providing the full output. The issue cannot be solved and will be considered
`invalid`. The command outputs more than you think, and we are adding more all the time. We do not
want to left guessing or trying things out to reproduce your issue.
- How did you install Nuitka and Python
Did you use pip, anaconda, deb, rpm, from source, git clone, then install into a virtualenv or
not, this is very important usually and one thing, the above command does not tell us (yet).
- The specific PyPI names and versions
It should be taken from this output if there specific packages involved, e.g. `numpy`, you are
expected to shorten this to the relevant ones.
> python -m pip freeze
- Many times when you get an error from Nuitka, your setup may be special
Then even a `print("hello world")` program will not work, please try that and report that error
instead. We do not need a report that says "Tensorflow does not work" when nothing actually works
for you. You ought to also read the User Manual and check that your setup is actually supported
already.
- Also supply a Short, Self Contained, Correct, Example
That demonstrates the issue i.e a small piece of code which reproduces the issue and can be run
with out any other (or as few as possible) external dependencies. Issues without this may will
likely be rejected without much consideration. Often this can be as simple as importing a package,
if this is a packaging issue, try that first.
Pointers to repositories with usage of `pipenv` are very welcome, archives with examples are too,
e.g. if a certain package structure is needed. This must be only source code, binaries are not
used ever by us. But beware, that e.g. we cannot click around and stuff. Still do an effort to
make the usage obvious. Having a compile script in the repo is perfect.
But this cannot be much code for non-commercial users, since that causes too much effort. We
cannot just compile your code, run it and have it download a control and command center.
- Provide in your issue the Nuitka options used
Ideally use the `# nuitka-project:` options feature in the code, so options and example code go
along. Alternatively state the command line.
[Nuitka Options in the code](https://nuitka.net/doc/user-manual.html#nuitka-options-in-the-code)
- Avoid unnecessary options
Do not use `--onefile` if the issue also happens with `--standalone`. Minimize the use of options
as far as you can, please. Do not disable outputs with `--quiet` and do not disable warnings.
- Note if this is a regression
If it used to work in an earlier version of Nuitka, please note what you know about that. Since
git bisect is a thing for which we do a lot of error to make it usable, this will help
dramatically to isolate the issue.
- Consider getting commercial support
[Nuitka commercial](https://nuitka.net/doc/commercial.html) offers subscriptions and priority
support. This will accelerate your problem solution and helps to sustain Nuitka development. Also
you then have a chance to provide source code of your project to us, which might simplify things,
or pay for time to solve your issues in your environment.
Some things are not welcome, please consider it.
- Do *not* post screenshots
These are not welcome unless absolutely necessary, e.g. because of Qt display problem, instead
capture the output of programs, so things are searchable and copy&paste will work. I just plainly
don't want to manually copy strings and hope they match.
- Do *not* close the issue yourself, we will close things on stable releases
We close issues only when they are released as a stable version, e.g. in a hotfix or a new
release, before that it will be "Done" in planning and go through `factory` and `develop` tags to
indicate they are solved there.
Of course, if you find out your issue is invalid, please do close it, and we then attach the
`invalid` tag.
- Do *not* report against factory version
Unless you were asked to test it there, it is frequently very broken, and there is only noise to
be had. Telling me about it on Discord would be a better idea.
- Do *not* let this template remain part of the issue, it's noise.
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
Thank your for contributing to Nuitka!
!! Please check that you select the **develop branch** (details see below link) !!
Before submitting a PR, please review the guidelines:
[Contributing Guidelines](https://github.com/Nuitka/Nuitka/blob/develop/CONTRIBUTING.md)
# What does this PR do?
# Why was it initiated? Any relevant Issues?
# PR Checklist
- [ ] Correct base branch selected? Should be `develop` branch.
- [ ] Enabled commit hook or executed `./bin/autoformat-nuitka-source`.
- [ ] All tests still pass. Check the Developer Manual about `Running the Tests`. There are GitHub
Actions tests that cover the most important things however, and you are welcome to rely on those,
but they might not cover enough.
- [ ] Ideally new features or fixed regressions ought to be covered via new tests.
- [ ] Ideally new or changed features have documentation updates.
================================================
FILE: .github/workflows/testing.yml
================================================
name: Nuitka tests
# makes little sense, spell-checker: disable
on:
pull_request:
branches:
- develop
push:
branches:
- main
- develop
- factory
- release/**
- hotfix/**
permissions:
contents: read
jobs:
linux:
runs-on: ubuntu-22.04
strategy:
matrix:
python_version:
- '3.7'
- '3.8'
- '3.9'
- '3.10'
- '3.11'
name: Ubuntu Python ${{ matrix.python_version }}
steps:
- name: 🛎️ Checkout
uses: actions/checkout@v3
with:
fetch-depth: 0
- name: 🐍 Use Python ${{ matrix.python_version }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python_version }}
- name: 🧳 Install Nuitka and dependencies
run: |
sudo apt-get update
sudo apt-get install patchelf gdb ccache libfuse2
python -m pip install --no-python-version-warning --disable-pip-version-check -r requirements-devel.txt
python -m pip install --no-python-version-warning --disable-pip-version-check .
- name: Verbose scons output in compilation
run: |
python -m nuitka --module --show-scons --run --report=compilation-report-module.xml --experimental=debug-report-traceback tests/basics/EmptyModuleTest.py
python -m nuitka --show-scons --run --report=compilation-report-exe.xml --experimental=debug-report-traceback tests/basics/EmptyModuleTest.py
- name: Archive compilation reports for empty modules
uses: actions/upload-artifact@v3
with:
name: compilation-reports
path: |
*.xml
# This can be used to ssh into GitHub actions if debugging is needed.
# - uses: actions/checkout@v2
# - name: Setup upterm session
# uses: lhotari/action-upterm@v1
# with:
# ## limits ssh access and adds the ssh public keys of the listed GitHub users
# limit-access-to-users: kayhayen
- name: Run Nuitka test suite
run: |
python -m nuitka --version
env | sort
python ./tests/run-tests --no-other-python --skip-reflection-test --skip-all-cpython-tests --assume-yes-for-downloads
- name: PyLint on Nuitka source code
run: |
python ./bin/check-nuitka-with-pylint
if: matrix.python_version == '3.9'
- name: RestLint on Nuitka source code
run: |
python ./bin/check-nuitka-with-restlint
if: matrix.python_version == '3.9'
- name: YamlLint on Nuitka source code
run: |
python ./bin/check-nuitka-with-yamllint
if: matrix.python_version == '3.9'
- name: Codespell on Nuitka source code
run: |
python ./bin/check-nuitka-with-codespell
if: matrix.python_version == '3.9'
- name: Auto-format check on Nuitka source code
run: |
# Install clang-format that matches what we use in VS code.
wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
sudo apt-get install software-properties-common
sudo add-apt-repository 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy main'
sudo apt-get update
sudo apt-get install clang-format-19
python ./bin/autoformat-nuitka-source --check-only
if: matrix.python_version == '3.9'
mac-python3:
runs-on: macos-latest
strategy:
matrix:
python_version:
- '3.7'
- '3.8'
- '3.9'
- '3.10'
- '3.11'
name: macOS Python ${{ matrix.python_version }}
steps:
- uses: actions/checkout@v3
- name: Use Python ${{ matrix.python_version }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python_version }}
- name: Verbose installation output for Python
run: |
set -x
which python
otool -L $(which python)
otool -l $(which python)
ls -lR $(dirname $(dirname $(which python)))
- name: 🧳 Install Nuitka and dependencies
run: |
pip install --no-python-version-warning --disable-pip-version-check -r requirements-devel.txt
pip install --no-python-version-warning --disable-pip-version-check .
- name: Verbose scons output in compilation
run: |
python -m nuitka --module --show-scons --run --assume-yes-for-downloads tests/basics/EmptyModuleTest.py
python -m nuitka --show-scons --run --assume-yes-for-downloads tests/basics/EmptyModuleTest.py
- name: Run Nuitka test suite
run: |
python -m nuitka --version
env | sort
python ./tests/run-tests --no-other-python --skip-reflection-test --skip-all-cpython-tests
windows:
runs-on: windows-latest
strategy:
matrix:
python_version:
- '3.7'
- '3.8'
- '3.9'
- '3.10'
- '3.11'
name: Windows Python ${{ matrix.python_version }}
steps:
- uses: actions/checkout@v3
- uses: ilammy/msvc-dev-cmd@v1
- name: Use Python ${{ matrix.python_version }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python_version }}
- name: 🧳 Install Nuitka and dependencies
run: |
pip install --no-python-version-warning --disable-pip-version-check -r requirements-devel.txt
pip install --no-python-version-warning --disable-pip-version-check .
- name: Verbose scons output in compilation
run: |
python -m nuitka --module --show-scons --run --assume-yes-for-downloads tests\basics\EmptyModuleTest.py
python -m nuitka --show-scons --run tests\basics\EmptyModuleTest.py
- name: Run Nuitka test suite
run: |
Get-ChildItem env:
python -m nuitka --version
python .\tests\run-tests --no-other-python --no-debug --skip-reflection-test --skip-all-cpython-tests --assume-yes-for-downloads
================================================
FILE: .gitignore
================================================
*~
*.DS_Store
*.e4t
*.e4q
*.e4s
*.pyc
__pycache__/
*.pyo
*.swp
*.swo
*.o
*.os
*.so
*.pyd
*.pyi
*.exe
*.exe.away
*.cmd
*.bin
*.build
*.onefile-build
*.dist
*.app
*.key
*.xml
*.optimization.log
*.inclusion.log
*.strace
*.dtruss
*.nuitka-pgo
.mypy_cache
*.egg-info
tests/reflected/nuitka/
tests/reflected/tests/
tests/reflected/nuitka.py
tests/reflected/nuitka-runner.py
tests/basics/BigConstants.py
tests/generated/*.py
!tests/generated/run_all.py
tests/PyPI-pytest/venv_*
*.dblite
*.pdb
releases/
html
man/
htmlcov/
Mini.py
python??.dll
python??_d.dll
build
!nuitka/build
dist
MANIFEST
README.pdf
README.html
Developer_Manual.pdf
Developer_Manual.html
Changelog.pdf
Changelog.html
doc/man-*.html
doxygen-warnings.log
venv_cpython/
venv_nuitka/
.pytest_cache
doxygen_*
doxygen-*
.coverage*
*.tmp
*.dat
.vscode/ipch
.vscode/tags
.vscode/.ropeproject
Nuitka-*
nuitka/tools/podman/containers/requirements-devel.txt
================================================
FILE: .gitmodules
================================================
[submodule "tests/CPython26"]
path = tests/CPython26
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython26
[submodule "tests/CPython27"]
path = tests/CPython27
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython27
[submodule "tests/CPython32"]
path = tests/CPython32
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython32
[submodule "tests/CPython33"]
path = tests/CPython33
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython33
[submodule "tests/CPython34"]
path = tests/CPython34
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython34
[submodule "tests/CPython35"]
path = tests/CPython35
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython35
[submodule "tests/CPython36"]
path = tests/CPython36
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython36
[submodule "tests/CPython37"]
path = tests/CPython37
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython37
[submodule "tests/CPython38"]
path = tests/CPython38
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython38
[submodule "tests/CPython39"]
path = tests/CPython39
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython39
[submodule "tests/CPython310"]
path = tests/CPython310
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython310
[submodule "tests/CPython311"]
path = tests/CPython311
url = https://github.com/Nuitka/Nuitka-CPython-tests.git
branch = CPython311
================================================
FILE: .sourcery.yaml
================================================
# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
ignore:
- "tests"
- "nuitka/build/inline_copy"
refactor:
python_version: '2.6'
# 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.
================================================
FILE: .vscode/c_cpp_properties.json
================================================
{
"env": {
"myDefaultIncludePath": [
"${workspaceFolder}/nuitka/build/include",
"${workspaceFolder}/nuitka/build/static_src",
"${workspaceFolder}/nuitka/build/inline_copy/zstd",
"${workspaceFolder}/nuitka/build/inline_copy/zlib",
"${workspaceFolder}/nuitka/build/inline_copy/libbacktrace"
]
},
"configurations": [
{
"name": "Win32",
"includePath": [
"${myDefaultIncludePath}",
"C:\\Python311\\Include"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x3b0"
],
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.31.31103/bin/Hostx64/x64/cl.exe",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "msvc-x64"
},
{
"name": "Win32-Py312",
"includePath": [
"${myDefaultIncludePath}",
"C:\\Python312\\Include"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x3c0"
],
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.31.31103/bin/Hostx64/x64/cl.exe",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "msvc-x64"
},
{
"name": "Win32-Py310",
"includePath": [
"${myDefaultIncludePath}",
"C:\\Python310\\Include"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x3a0"
],
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.31.31103/bin/Hostx64/x64/cl.exe",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "msvc-x64"
},
{
"name": "Win32-Py27",
"includePath": [
"${myDefaultIncludePath}",
"C:\\Python27\\Include"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x270"
],
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.31.31103/bin/Hostx64/x64/cl.exe",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "msvc-x64"
},
{
"name": "Linux-Python3.9",
"includePath": [
"/usr/include",
"${myDefaultIncludePath}",
"/usr/include/python3.9"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x390"
],
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "${default}"
},
{
"name": "Linux-Python3.10",
"includePath": [
"/usr/include",
"${myDefaultIncludePath}",
"/usr/include/python3.10"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x3a0"
],
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "${default}"
},
{
"name": "Linux-Python3.11",
"includePath": [
"/usr/include",
"${myDefaultIncludePath}",
"/usr/include/python3.11"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x3B0"
],
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "${default}"
},
{
"name": "Linux-Python2.7",
"includePath": [
"/usr/include",
"${myDefaultIncludePath}",
"/usr/include/python2.7"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x270"
],
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "${default}"
},
{
"name": "Mac",
"includePath": [
"${myDefaultIncludePath}",
"/Library/Frameworks/Python.framework/Versions/3.11/include/python3.11"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"__IDE_ONLY__",
"PYTHON_VERSION=0x3B0"
],
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "${default}"
}
],
"version": 4
}
================================================
FILE: .vscode/extensions.json
================================================
{
// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
// List of extensions which should be recommended for users of this workspace.
"recommendations": [
"ms-python.python",
"lextudio.restructuredtext",
"foxundermoon.shell-format",
"troelsdamgaard.reflow-paragraph",
"ms-vscode.cpptools",
"mervin.markdown-formatter",
"stkb.rewrap",
"trond-snekvik.simple-rst",
"redhat.vscode-yaml",
"dawidd6.debian-vscode",
"streetsidesoftware.code-spell-checker",
"samuelcolvin.jinjahtml",
"tamasfe.even-better-toml"
],
// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
"unwantedRecommendations": [
]
}
================================================
FILE: .vscode/settings.json
================================================
{
"files.trimTrailingWhitespace": true,
"files.trimFinalNewlines": true,
"C_Cpp.dimInactiveRegions": false,
"files.exclude": {
"**/*.onefile-build": true,
"**/*.build": true,
"**/*.dist": true,
"**/*.exe": true,
"**/*.exe.away": true,
"**/*.bin": true,
"**/*.pyc": true,
"**/__pycache__": true,
"**/*.orig": true,
"**/*.tmp": true,
"tests/reflected/nuitka": true,
"tests/distutils/venv_*": true,
"build": true,
},
"files.associations": {
"*.tac": "python",
"*.inc": "restructuredtext",
"*.scons": "python",
"*.sco": "python",
"*.h": "c",
"*.c": "c",
"typeinfo": "c",
"cstring": "c",
"optional": "c",
"istream": "c",
"ostream": "c",
"system_error": "c",
"array": "c",
"functional": "c",
"tuple": "c",
"type_traits": "c",
"utility": "c",
"memory": "c",
"onefilesplashscreen.cpp": "cpp",
"compare": "c",
"string_view": "c",
"initializer_list": "c",
"ranges": "c",
"chrono": "c",
"ratio": "c",
"__hash_table": "c",
"__split_buffer": "c",
"bitset": "c",
"string": "c",
"unordered_map": "c",
"vector": "c",
"xtr1common": "c",
"__locale": "c",
"atomic": "c",
"__functional_base": "c",
"__functional_base_03": "c",
"__tuple": "c",
"algorithm": "c",
"limits": "c",
"random": "c",
"__bit_reference": "c",
"__node_handle": "c",
"deque": "c",
"__memory": "c",
"iterator": "c",
"locale": "c"
},
"python.analysis.autoSearchPaths": false,
"python.analysis.extraPaths": [
"nuitka/build/inline_copy/lib/scons-3.1.2",
"nuitka/build/inline_copy/clcache"
],
"python.analysis.diagnosticSeverityOverrides": {
"reportMissingImports": "none"
},
"cSpell.words": [
"__abstractmethods__",
"__aenter__",
"__aexit__",
"__cplusplus",
"__newobj__",
"__warningregistry__",
"_NUITKA_WINMAIN_ENTRY_POINT",
"_Py_DEC_REFTOTAL",
"_Py_DecodeUTF8_surrogateescape",
"_PyDict_NewPresized",
"_wtoi",
"_XOPEN_SOURCE",
"abiflags",
"abspath",
"abstractmethod",
"abstractproperty",
"appdirs",
"asyncgen",
"backslashreplace",
"basenames",
"basestring",
"binaryfunc",
"bitor",
"Buildbot",
"bytearray",
"bytecode",
"bytecodes",
"CAPI",
"CBOOL",
"ccache",
"CFLOAT",
"cframe",
"clangcl",
"clcache",
"CLONG",
"clonglong",
"closefd",
"co_argcount",
"co_firstlineno",
"co_freevars",
"co_has_stardict",
"co_has_starlist",
"co_kwonlyargcount",
"co_nconsts",
"CO_NEWLOCALS",
"CO_NOFREE",
"co_posonlyargcount",
"CO_VARKEYWORDS",
"co_varnames",
"codesign",
"codespell",
"compactify",
"conda",
"condition-evals-to-constant",
"containerfile",
"CORO_CLOSED",
"CORO_CREATED",
"CORO_RUNNING",
"CORO_SUSPENDED",
"cpython",
"ctypes",
"curexc_traceback",
"curexc_type",
"curexc_value",
"Cython",
"deepcopy",
"Dejong",
"descrgetfunc",
"descrsetfunc",
"devel",
"devnull",
"diffable",
"distutils",
"Doxygen",
"dpkg",
"dtrace",
"dtruss",
"dunder",
"DYLD",
"dylib",
"elif",
"embeddable",
"EPEL",
"finalizer",
"FLUFL",
"fromlist",
"frozenset",
"fstrings",
"genericalias",
"genexpr",
"getpreferredencoding",
"gettotalrefcount",
"girepository",
"Gitter",
"hasattr",
"hashable",
"haskey",
"Hayen",
"HEDLEY",
"hotfixes",
"ibitand",
"ibitor",
"ibitxor",
"idna",
"imatmult",
"importlib",
"imult",
"incbin",
"inplace",
"iolddiv",
"ipython",
"isabs",
"isdir",
"isfile",
"isgen",
"isgenerator",
"isort",
"iterdir",
"iteritems",
"iterkeys",
"iternextfunc",
"itervalues",
"joinpath",
"jsonschema",
"Kivy",
"kwargs",
"kwds",
"lasti",
"ldconfig",
"libc",
"libpython",
"lintian",
"listdir",
"lldb",
"longlong",
"LPWSTR",
"lxml",
"manylinux",
"Matmult",
"mdef",
"metaclass",
"metaclasses",
"metapath",
"METH_NOARGS",
"METH_VARARGS",
"MSVC",
"msys",
"Mult",
"multidist",
"namedtuples",
"Namify",
"NBOOL",
"no_docstrings",
"noelf",
"nofollow",
"noinclude",
"nosite",
"nowarn",
"Nuitka",
"Numba",
"numberize",
"numpy",
"ob_sval",
"olddiv",
"onefile",
"optipng",
"organisation",
"Organisational",
"otool",
"pacman",
"patchelf",
"pathlib",
"pbuilder",
"Pickler",
"pipenv",
"pkglib",
"Podman",
"POSIX",
"Py_DECREF",
"Py_INCREF",
"PY_NOGIL",
"Py_REFCNT",
"Py_ssize_t",
"Py_TPFLAGS",
"Py_TPFLAGS_HAVE_WEAKREFS",
"Py_TPFLAGS_HEAPTYPE",
"Py_XDECREF",
"Py_XINCREF",
"PYCORE",
"PyCoro_Type",
"pyenv",
"PyErr_WriteUnraisable",
"pygsheets",
"pylint",
"pyproject",
"pyqt",
"pyside",
"PYSTATE",
"pystone",
"PYTHONHASHSEED",
"PYTHONHOME",
"PYTHONIOENCODING",
"PYTHONPATH",
"pythonw",
"Qualname",
"redist",
"reexecute",
"repr",
"reprfunc",
"richcmpfunc",
"roadmap",
"rpartition",
"RPATH",
"rpaths",
"RT_RCDATA",
"Scons",
"setattrofunc",
"Setuptools",
"sourcery",
"ssizeargfunc",
"startswith",
"staticmethod",
"stdlib",
"strchr",
"subclasscheck",
"sysexit",
"sysflag",
"Termux",
"ternaryfunc",
"Themida",
"Tkinter",
"tp_alloc",
"tp_basicsize",
"tp_dealloc",
"tp_descr_get",
"tp_descr_set",
"tp_dictoffset",
"tp_getattro",
"tp_getset",
"tp_itemsize",
"tp_iternext",
"tp_richcompare",
"tp_setattro",
"tp_vectorcall_offset",
"tp_weaklist",
"tp_weaklistoffset",
"traceback",
"tracebacks",
"traverseproc",
"truediv",
"tshape",
"tstate",
"ucrt",
"uncompiled",
"unoptimized",
"unorderable",
"unstripped",
"Valgrind",
"vectorcall",
"vectorcallfunc",
"viewitems",
"viewkeys",
"viewvalues",
"virtualenv",
"visitproc",
"vmprof",
"vshape",
"wargv",
"wcsicmp",
"winlibs",
"wmain",
"zstandard",
"zstd"
],
"esbonio.server.enabled": true,
"esbonio.sphinx.confDir": "",
"cSpell.spellCheckOnlyWorkspaceFiles": true,
"cSpell.ignorePaths": [
".git",
".vscode",
"Mini*.py",
],
"yaml.schemas": {
"misc/nuitka-package-config-schema.json": [
"*.nuitka-package.config.yml",
"*.nuitka-package.config.yaml",
]
},
"yaml.maxItemsComputed": 10000,
"[python]": {
"editor.defaultFormatter": "ms-python.black-formatter"
}
}
================================================
FILE: CODE_OF_CONDUCT.rst
================================================
######################################
Contributor Covenant Code of Conduct
######################################
************
Our Pledge
************
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to making participation in our
project and our community a harassment-free experience for everyone,
regardless of age, body size, disability, ethnicity, sex
characteristics, gender identity and expression, level of experience,
education, socio-economic status, nationality, personal appearance,
race, religion, or sexual identity and orientation.
***************
Our Standards
***************
Examples of behavior that contributes to creating a positive environment
include:
- Using welcoming and inclusive language
- Being respectful of differing viewpoints and experiences
- Gracefully accepting constructive criticism
- Focusing on what is best for the community
- Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
- The use of sexualized language or imagery and unwelcome sexual
attention or advances
- Trolling, insulting/derogatory comments, and personal or political
attacks
- Public or private harassment
- Publishing other's private information, such as a physical or
electronic address, without explicit permission
- Other conduct which could reasonably be considered inappropriate in a
professional setting
**********************
Our Responsibilities
**********************
Maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action
in response to any instances of unacceptable behavior.
Maintainers have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem
inappropriate, threatening, offensive, or harmful.
*******
Scope
*******
This Code of Conduct applies both within project spaces and in public
spaces when an individual is representing the project or its community.
Examples of representing a project or community include using an
official project e-mail address, posting via an official social media
account, or acting as an appointed representative at an online or
offline event. Representation of a project may be further defined and
clarified by project maintainers.
*************
Enforcement
*************
Instances of abusive, harassing, or otherwise unacceptable behavior may
be reported by contacting the Nuitka Organisation admins via email to
"kay@nuitka.net". Use "COD complaint:" in your email subject. All
complaints will be reviewed and investigated and will result in a
response that is deemed necessary and appropriate to the circumstances.
The Code of Conduct Committee is obligated to maintain confidentiality
with regard to the reporter of an incident. Further details of specific
enforcement policies may be posted separately.
*************
Attribution
*************
This Code of Conduct is adapted from the Contributor Covenant, version
1.4, available at
https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
and the Linux kernel team changes as available under
https://docs.kernel.org/_sources/process/code-of-conduct.rst.txt
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to Nuitka
## First things
Welcome on board. Nuitka is an ambitious project. We are friendly. Join it now.
This document aims to give an overview of how to contribute to Nuitka. It tries
to answer commonly asked questions regarding that, and to provide some insight on how to do it properly.
- If you plan on submitting an issue
Please follow this [template](https://github.com/Nuitka/Nuitka/blob/develop/.github/ISSUE_TEMPLATE.md).
- If you want to open a pull request
Make sure to read the information on further down this page but also have a
look at our [pull request
template](https://github.com/Nuitka/Nuitka/blob/develop/.github/PULL_REQUEST_TEMPLATE.md).
## Getting Started
- Read the [Nuitka User Manual](https://nuitka.net/doc/user-manual.html)
- Read the [Nuitka Developer Manual](https://nuitka.net/doc/developer-manual.html)
- Checkout the [git repo of Nuitka](https://github.com/Nuitka/Nuitka) additional docs and sources
- Join the [Discord Server](https://discord.gg/nZ9hr9tUck)
## Submitting a Pull Request
Pull requests are great. Here's a quick guide:
1. Fork the repo on github.
2. Install the `pre-commit` git hook
That is going to automatically format your code as described in the
Developer Manual. For that you have to execute this:
python misc/install-git-hooks.py
3. Make a new branch and base your new branch on `develop`.
4. Ideally add a test specific for your change to demonstrate it.
Due to Nuitka testing being basically to compile the whole world, it's ok to
not have one. But obviously if you fix something, it wasn't observed by that,
it would be good to provide a reproducer.
5. Make the tests pass.
6. Push to your fork and submit a pull request against `nuitka:develop`
7. Wait for review
Suggestions for improvements or alternative ideas may happen. Keep in mind that
PR checklist items can be met after the pull request has been opened by adding
more commits to the branch. Indicate work in progress with a `WIP:` prefix in your PR title.
All the submitted pieces including potential data must be compatible with the
Apache License 2, which already says that once you are sending modified source,
e.g. via pull request, you automatically license it as that too.
## Submitting a Question
If you want to ask a question about a specific Nuitka aspect, please be kind
and first of all..
- Search for existing issues
Consider [GitHub issues tagged as "question"](https://github.com/Nuitka/Nuitka/issues?q=label%3Aquestion)
- If not asked yet, ask it there.
## Submitting Issues
The issue template contains the guidance on how to properly support issues. If you ignore it, likely the issue will be closed as invalid. We cannot really make guesses.
================================================
FILE: Changelog.rst
================================================
##################
Nuitka Changelog
##################
In this document, we track the per version changes and comments. This is
now maintained separately at https://nuitka.net/changelog/Changelog.html please
check it out from there.
================================================
FILE: Developer_Manual.rst
================================================
#########################
Nuitka Developer Manual
#########################
The purpose of this Developer Manual is to present the current design of
Nuitka, the project rules, and the motivations for choices made. It is
intended to be a guide to the source code, and to give explanations that
don't fit into the source code in comments form.
It should be used as a reference for the process of planning and
documenting decisions we made. Therefore we are e.g. presenting here the
type inference plans before implementing them. And we update them as we
proceed.
It grows out of discussions and presentations made at conferences as
well as private conversations or issue tracker.
************
Milestones
************
#. Feature parity with CPython, understand all the language construct
and behave absolutely compatible.
Feature parity has been reached for CPython 2.6 and 2.7. We do not
target any older CPython release. For CPython 3.3 up to 3.8 it also
has been reached. We do not target the older and practically unused
CPython 3.0 to 3.2 releases.
This milestone was reached. Dropping support for Python 2.6 and 3.3
is an option, should this prove to be any benefit. Currently it is
not, as it extends the test coverage only.
#. Create the most efficient native code from this. This means to be
fast with the basic Python object handling.
This milestone was reached, although of course, micro optimizations
to this are happening all the time.
#. Then do constant propagation, determine as many values and useful
constraints as possible at compile time and create more efficient
code.
This milestone is considered almost reached. We continue to discover
new things, but the infrastructure is there, and these are easy to
add.
#. Type inference, detect and special case the handling of strings,
integers, lists in the program.
This milestone is considered in progress.
#. Add interfacing to C code, so Nuitka can turn a ``ctypes`` binding
into an efficient binding as written with C.
This milestone is planned only.
#. Add hints module with a useful Python implementation that the
compiler can use to learn about types from the programmer.
This milestone is planned only.
*****************
Version Numbers
*****************
For Nuitka we use semantic versioning, initially with a leading zero
still, once we pass release ``1.9``, the scheme will indicate the ``10``
through using ``2.0``.
***************
Current State
***************
Nuitka top level works like this:
- ``nuitka.tree.Building`` outputs node tree
- ``nuitka.optimization`` enhances it as best as it can
- ``nuitka.finalization`` prepares the tree for code generation
- ``nuitka.code_generation.CodeGeneration`` orchestrates the creation
of code snippets
- ``nuitka.code_generation.*Codes`` knows how specific code kinds are
created
- ``nuitka.MainControl`` keeps it all together
This design is intended to last.
Regarding types, the state is:
- Types are always ``PyObject *``, and only a few C types, e.g.
``nuitka_bool`` and ``nuitka_void`` and more are coming. Even for
objects, often it's know that things are e.g. really a
``PyTupleObject **``, but no C type is available for that yet.
- There are a some specific use of types beyond "compile time
constant", that are encoded in type and value shapes, which can be
used to predict some operations, conditions, etc. if they raise, and
result types they give.
- In code generation, the supported C types are used, and sometimes we
have specialized code generation, e.g. a binary operation that takes
an ``int`` and a ``float`` and produces a ``float`` value. There will
be fallbacks to less specific types.
The expansion with more C types is currently in progress, and there will
also be alternative C types, where e.g. ``PyObject *`` and ``C long``
are in an enum that indicates which value is valid, and where special
code will be available that can avoid creating the ``PyObject **``
unless the later overflows.
***************************************************
Setting up the Development Environment for Nuitka
***************************************************
Currently there are very different kinds of files that we need support
for. This is best addressed with an IDE. We cover here how to setup the
most common one.
Visual Studio Code
==================
Download Visual Studio Code from here:
https://code.visualstudio.com/download
At this time, this is the recommended IDE for Linux and Windows. This is
going to cover the plugins to install. Configuration is part of the
``.vscode`` in your Nuitka checkout. If you are not familiar with
Eclipse, this is Free Software IDE,designed to be universally extended,
and it truly is. There are plugins available for nearly everything.
The extensions to be installed are part of the Visual Code
recommendations in ``.vscode/extensions.json`` and you will be prompted
about that and ought to install these.
Eclipse / PyCharm
=================
Don't use these anymore, we consider Visual Studio Code to be far
superior for delivering a nice out of the box environment.
*************************
Commit and Code Hygiene
*************************
In Nuitka we have tools to auto format code, you can execute them
manually, but it's probably best to execute them at commit time, to make
sure when we share code, it's already well format, and to avoid noise
doing cleanups.
The kinds of changes also often cause unnecessary merge conflicts, while
the auto format is designed to format code also in a way that it avoids
merge conflicts in the normal case, e.g. by doing imports one item per
line.
In order to set up hooks, you need to execute these commands:
.. code:: bash
# Where python is the one you use with Nuitka, this then gets all
# development requirements, can be full PATH.
python -m pip install -r requirements-devel.txt
python ./misc/install-git-hooks.py
These commands will make sure that the ``autoformat-nuitka-source`` is
run on every staged file content at the time you do the commit. For C
files, it may complain unavailability of ``clang-format``, follow it's
advice. You may call the above tool at all times, without arguments to
format call Nuitka source code.
Should you encounter problems with applying the changes to the checked
out file, you can always execute it with ``COMMIT_UNCHECKED=1``
environment set.
*********************
Coding Rules Python
*********************
These rules should generally be adhered when working on Nuitka code.
It's not library code and it's optimized for readability, and avoids all
performance optimization for itself.
Tool to format
==============
There is a tool ``bin/autoformat-nuitka-source`` which is to apply
automatic formatting to code as much as possible. It uses ``black``
(internally) for consistent code formatting. The imports are sorted with
``isort`` for proper order.
The tool (mostly ``black`` and ``isort``) encodes all formatting rules,
and makes the decisions for us. The idea being that we can focus on
actual code and do not have to care as much about other things. It also
deals with Windows new lines, trailing space, etc. and even sorts PyLint
disable statements.
Identifiers
===========
Classes
-------
Classes are camel case with leading upper case. Functions and methods
are with leading verb in lower case, but also camel case. Variables and
arguments are lower case with ``_`` as a separator.
.. code:: python
class SomeClass:
def doSomething(some_parameter):
some_var = ("foo", "bar")
Base classes that are abstract have their name end with ``Base``, so
that a meta class can use that convention, and readers immediately know,
that it will not be instantiated like that.
Functions
---------
Function calls use keyword argument preferably. These are slower in
CPython, but more readable:
.. code:: python
getSequenceCreationCode(
sequence_kind=sequence_kind, element_identifiers=identifiers, context=context
)
When the names don't add much value, sequential calls can be done:
.. code:: python
context.setLoopContinueTarget(handler_start_target)
Here, ``setLoopContinueTarget`` will be so well known that the reader is
expected to know the argument names and their meaning, but it would be
still better to add them. But in this instance, the variable name
already indicates that it is.
Module/Package Names
--------------------
Normal modules are named in camel case with leading upper case, because
of their role as singleton classes. The difference between a module and
a class is small enough and in the source code they are also used
similarly.
For the packages, no real code is allowed in their ``__init__.py`` and
they must be lower case, like e.g. ``nuitka`` or ``codegen``. This is to
distinguish them from the modules.
Packages shall only be used to group things. In
``nuitka.code_generation`` the code generation packages are located,
while the main interface is ``nuitka.code_generation.CodeGeneration``
and may then use most of the entries as local imports.
There is no code in packages themselves. For programs, we use
``__main__`` package to carry the actual code.
Names of modules should be plurals if they contain classes. Example is
that a ``Nodes`` module that contains a ``Node`` class.
Context Managers
----------------
Names for context manages start with ``with``
In order to easily recognize that something is to be used as a context
manager, we follow a pattern of naming them ``withSomething``, to make
that easily recognized.
.. code:: python
with withEnvironmentPathAdded(os.path.join(sys.prefix, "bin")):
with withDirectoryChange(self.qt_datadir):
...
This makes these easy to recognize even in their definition.
Prefer list contractions over built-ins
=======================================
This concerns ``map``, ``filter``, and ``apply``. Usage of these
built-ins is highly discouraged within Nuitka source code. Using them is
considered worth a warning by "PyLint" e.g. "Used built-in function
'map'". We should use list contractions instead, because they are more
readable.
List contractions are a generalization for all of them. We love
readability and with Nuitka as a compiler, there won't be any
performance difference at all.
There are cases where a list contraction is faster because you can avoid
to make a function call. And there may be cases, where map is faster, if
a function must be called. These calls can be very expensive in CPython,
and if you introduce a function, just for ``map``, then it might be
slower.
But of course, Nuitka is the project to free us from what is faster and
to allow us to use what is more readable, so whatever is faster, we
don't care. We make all options equally fast and let people choose.
For Nuitka the choice is list contractions as these are more easily
changed and readable.
Look at this code examples from Python:
.. code:: python
class A:
def getX(self):
return 1
x = property(getX)
class B(A):
def getX(self):
return 2
A().x == 1 # True
B().x == 1 # True (!)
This pretty much is what makes properties bad. One would hope ``B().x``
to be ``2``, but instead it's not changed. Because of the way properties
take the functions and not members, and because they then are not part
of the class, they cannot be overloaded without re-declaring them.
Overloading is then not at all obvious anymore. Now imagine having a
setter and only overloading the getter. How to update the property
easily?
So, that's not likable about them. And then we are also for clarity in
these internal APIs too. Properties try and hide the fact that code
needs to run and may do things. So let's not use them.
For an external API you may exactly want to hide things, but internally
that has no use, and in Nuitka, every API is internal API. One exception
may be the ``hints`` module, which will gladly use such tricks for an
easier write syntax.
****************
Coding Rules C
****************
For the static C parts, e.g. compiled types, helper codes, the
``clang-format`` from LLVM project is used, the tool
``autoformat-nuitka-source`` does this for us.
We always have blocks for conditional statements to avoid typical
mistakes made by adding a statement to a branch, forgetting to make it a
block.
**********************
The "git flow" model
**********************
- The flow is used for releases and occasionally subsequent hot fixes.
A few feature branches were used so far. It allows for quick delivery
of fixes to both the stable and the development version, supported by
a git plug-in, that can be installed via "apt-get install git-flow".
- Stable (``main`` branch)
The stable version, is expected to pass all the tests at all times
and is fully supported. As soon as bugs are discovered, they are
fixed as hot fixes, and then merged to develop by the "git flow"
automatically.
- Development (``develop`` branch)
The future release, supposedly in almost ready for release state at
nearly all times, but this is less strict. It is not officially
supported, and may have problems and at times inconsistencies.
Normally this branch is supposed to not be rebased. For severe
problems it may be done though.
- Factory (default feature branch)
Code under construction. We publish commits there, that may not hold
up in testing, and before it enters develop branch. Factory may have
severe regressions frequently, and commits become **rebased all the
time**, so do not base your patches on it, please prefer the
``develop`` branch for that, unless of course, it's about factory
code itself.
- Personal branches (jorj, orsiris, others as well)
We are currently not using this, but it's an option.
- Feature Branches
We are not currently using these. They could be used for long lived
changes that extend for multiple release cycles and are not ready
yet. Currently we perform all changes in steps that can be included
in releases or delay making those changes.
******************************
Nuitka "git/github" Workflow
******************************
- Forking and cloning
You need to have git installed and GitHub account. Goto Nuitka
repository <https://github.com/Nuitka/Nuitka> and fork the
repository.
To clone it to your local machine execute the following your git
bash:
.. code:: bash
git clone https://github.com/your-user-name/Nuitka.git
cd Nuitka
git remote add upstream https://github.com/Nuitka/Nuitka.git
- Create a Branch
.. code:: bash
git checkout develop
git pull --rebase upstream
git checkout -b feature_branch
If you are having merge conflicts while doing the previous step, then
check out (DON'T FORGET TO SAVE YOUR CHANGES FIRST IF ANY):
<https://stackoverflow.com/questions/1125968/how-do-i-force-git-pull-to-overwrite-local-files>
- In case you have an existing branch rebase it to develop
.. code:: bash
git fetch upstream
git rebase upstream/develop
Fix the merge conflicts if any and continue or skip commit if it is
not your. Sometimes for important bug fixes, develop history gets
rewritten. In that case, old and new commits will conflict during
your rebase, and skipping is the best way to go.
.. code:: bash
git rebase --continue
# not your commit:
git rebase --skip
If anything goes wrong while rebasing:
.. code:: bash
git rebase --abort
- Making changes
.. code:: bash
git commit -a -m "Commit Message"
git push -u origin # once, later always:
git push
**********************************
API Documentation and Guidelines
**********************************
There is API documentation generated with ``doxygen``, available at
`this location <https://nuitka.net/apidoc>`__ .
To ensure meaningful ``doxygen`` output, the following guidelines must
be observed when creating or updating Python source:
Use of Standard Python ``__doc__`` Strings
==========================================
Every class and every method should be documented via the standard
Python delimiters (``""" ... """``) in the usual way.
Special ``doxygen`` Anatomy of ``__doc__``
==========================================
.. note::
We are replacing Doxygen with sphinx, this is all obsolete
- Immediately after the leading ``"""``, and after 1 space on the same
line, enter a brief description or title of the class or method. This
must be 1 line and be followed by at least 1 empty line.
- Depending on the item, choose from the following "sections" to
describe what the item is and does.
Each section name is coded on its own line, aligned with the leading
``"""`` and followed by a colon ":". Anything following the section,
must start on a new line and be indented by 4 spaces relative to the
section. Except for the first section (``Notes:``) after the title,
sections need not be preceded by empty lines -- but it is good
practice to still do that.
- ``Notes:`` detailed description of the item, any length.
May contain line breaks with each new line starting aligned with
previous one. The text will automatically be joined across line
breaks and be reformatted in the browser.
If you describe details for a class, you can do so **without**
using this section header and all formatting will still work fine.
If you however omit the ``Notes:`` for methods, then the text will
be interpreted **as code**, be shown in an ugly monospaced font,
and no automatic line breaks will occur in the browser.
- ``Args:`` positional arguments.
Each argument then follows, starting on a new line and indented by
4 spaces. The argument name must be followed by a colon ``:`` or
double hash ``--``, followed by a description of arbitrary length.
The description can be separated by line breaks.
- ``Kwargs:`` keyword arguments. Same rules as for args.
- ``Returns:`` description of what will be returned if applicable
(any length).
- ``Yields:`` synonymous for ``Returns:``.
- ``Raises:`` name any exceptions that may be raised.
- ``Examples:`` specify any example code.
.. code:: python
def foo(p1, p2, kw1=None, kw2=None):
"""This is an example method.
Notes:
It does one or the other indispensable things based on some parameters
and proudly returns a dictionary.
Args:
p1: parameter one
p2: parameter two
Kwargs:
kw1: keyword one
kw2: keyword two
Returns:
A dictionary calculated from the input.
Raises:
ValueError, IndexError
Examples:
>>> foo(1, 2, kw1=3, kw2=4)
{'a': 4, 'b': 6}
"""
*********************
Checking the Source
*********************
The static checking for errors is currently done with ``PyLint``. In the
future, Nuitka itself will gain the ability to present its findings in a
similar way, but this is not a priority, and we are not there yet.
So, we currently use ``PyLint`` with options defined in a script.
.. code:: bash
./bin/check-nuitka-with-pylint
The above command is expected to give no warnings. It is also run on our
CI and we will not merge branches that do not pass.
*******************
Running the Tests
*******************
This section describes how to run Nuitka tests.
Running all Tests
=================
The top level access to the tests is as simple as this:
.. code:: bash
./tests/run-tests
For fine grained control, it has the following options:
.. code::
--skip-basic-tests The basic tests, execute these to check if Nuitka is
healthy. Default is True.
--skip-syntax-tests The syntax tests, execute these to check if Nuitka
handles Syntax errors fine. Default is True.
--skip-program-tests The programs tests, execute these to check if Nuitka
handles programs, e.g. import recursions, etc. fine.
Default is True.
--skip-package-tests The packages tests, execute these to check if Nuitka
handles packages, e.g. import recursions, etc. fine.
Default is True.
--skip-optimizations-tests
The optimization tests, execute these to check if
Nuitka does optimize certain constructs fully away.
Default is True.
--skip-standalone-tests
The standalone tests, execute these to check if Nuitka
standalone mode, e.g. not referring to outside,
important 3rd library packages like PyQt fine. Default
is True.
--skip-reflection-test
The reflection test compiles Nuitka with Nuitka, and
then Nuitka with the compile Nuitka and compares the
outputs. Default is True.
--skip-cpython26-tests
The standard CPython2.6 test suite. Execute this for
all corner cases to be covered. With Python 2.7 this
covers exception behavior quite well. Default is True.
--skip-cpython27-tests
The standard CPython2.7 test suite. Execute this for
all corner cases to be covered. With Python 2.6 these
are not run. Default is True.
--skip-cpython32-tests
The standard CPython3.2 test suite. Execute this for
all corner cases to be covered. With Python 2.6 these
are not run. Default is True.
--skip-cpython33-tests
The standard CPython3.3 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython34-tests
The standard CPython3.4 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython35-tests
The standard CPython3.5 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython36-tests
The standard CPython3.6 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython37-tests
The standard CPython3.7 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython38-tests
The standard CPython3.8 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython39-tests
The standard CPython3.9 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython310-tests
The standard CPython3.10 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--skip-cpython311-tests
The standard CPython3.11 test suite. Execute this for
all corner cases to be covered. With Python 2.x these
are not run. Default is True.
--no-python2.6 Do not use Python 2.6 even if available on the system.
Default is False.
--no-python2.7 Do not use Python 2.7 even if available on the system.
Default is False.
--no-python3.3 Do not use Python 3.3 even if available on the system.
Default is False.
--no-python3.4 Do not use Python 3.4 even if available on the system.
Default is False.
--no-python3.5 Do not use Python 3.5 even if available on the system.
Default is False.
--no-python3.6 Do not use Python 3.6 even if available on the system.
Default is False.
--no-python3.7 Do not use Python 3.7 even if available on the system.
Default is False.
--no-python3.8 Do not use Python 3.8 even if available on the system.
Default is False.
--no-python3.9 Do not use Python 3.9 even if available on the system.
Default is False.
--no-python3.10 Do not use Python 3.10 even if available on the system.
Default is False.
--no-python3.11 Do not use Python 3.11 even if available on the system.
Default is False.
--coverage Make a coverage analysis, that does not really check.
Default is False.
You will only run the CPython test suites, if you have the submodules of
the Nuitka git repository checked out. Otherwise, these will be skipped
with a warning that they are not available.
The policy is generally, that ``./test/run-tests`` running and passing
all the tests on Linux and Windows shall be considered sufficient for a
release, but of course, depending on changes going on, that might have
to be expanded.
Basic Tests
===========
You can run the "basic" tests like this:
.. code:: bash
./tests/basics/run_all.py search
These tests normally give sufficient coverage to assume that a change is
correct, if these "basic" tests pass. The most important constructs and
built-ins are exercised.
To control the Python version used for testing, you can set the
``PYTHON`` environment variable to e.g. ``python3.5`` (can also be full
path), or simply execute the ``run_all.py`` script directly with the
intended version, as it is portable across all supported Python
versions, and defaults testing with the Python version is run with.
Syntax Tests
============
Then there are "syntax" tests, i.e. language constructs that need to
give a syntax error.
It sometimes so happens that Nuitka must do this itself, because the
``ast.parse`` doesn't see the problem and raises no ``SyntaxError`` of
its own. These cases are then covered by tests to make sure they work as
expected.
Using the ``global`` statement on a function argument is an example of
this. These tests make sure that the errors of Nuitka and CPython are
totally the same for this:
.. code:: bash
./tests/syntax/run_all.py search
Program Tests
=============
Then there are small "programs" tests, that e.g. exercise many kinds of
import tricks and are designed to reveal problems with inter-module
behavior. These can be run like this:
.. code:: bash
./tests/programs/run_all.py search
Generated Tests
===============
There are tests, which are generated from Jinja2 templates. They aim at
e.g. combining at types with operations, in-place or not, or large
constants. These can be run like this:
.. code:: bash
./tests/generated/run_all.py search
Compile Nuitka with Nuitka
==========================
And there is the "compile itself" or "reflected" test. This test makes
Nuitka compile itself and compare the resulting C++ when running
compiled to non-compiled, which helps to find in-determinism.
The test compiles every module of Nuitka into an extension module and
all of Nuitka into a single binary.
That test case also gives good coverage of the ``import`` mechanisms,
because Nuitka uses a lot of packages and imports between them.
.. code:: bash
./tests/reflected/compile_itself.py
*********************
Internal/Plugin API
*********************
The documentation from the source code for both the Python and the C
parts are published as `Nuitka API <https://nuitka.net/apidoc>`__ and
arguably in a relatively bad shape as we started generating those with
Doxygen only relatively late.
.. code:: bash
doxygen ./doc/Doxyfile
xdg-open html
Improvements have already been implemented for plugins: The plugin base
class defined in ``PluginBase.py`` (which is used as a template for all
plugins) is fully documented in Doxygen now. The same is true for the
recently added standard plugins ``NumpyPlugin.py`` and
``TkinterPlugin.py``. These will be uploaded very soon.
Going forward, this will also happen for the remaining standard plugins.
Please find `here
<https://github.com/Nuitka/Nuitka/blob/develop/UserPlugin-Creation.rst>`__
a detailed description of how to write your own plugin.
To learn about plugin option specification consult `this document
<https://github.com/Nuitka/Nuitka/blob/develop/Using-Plugin-Options.rst>`__.
*********************************
Working with the CPython suites
*********************************
Resetting CPython suites
========================
The CPython test suites are different branches of the same submodule.
When you update your git checkout, they will frequently become detached.
In this case, simply execute this command:
.. code:: bash
git submodule foreach 'git fetch && git checkout $(basename $(pwd)) && \
git reset --hard origin/$(basename $(pwd))'
Added new CPython suites
========================
When adding a test suite, for a new version, proceed like this, of
course while adapting of course the names. These are the commands used
for adding CPython311 based on the CPython310 branch.
.. code:: bash
# Switch to a new branch.
git checkout CPython310
git branch CPython311
git checkout CPython311
# Delete all but root commit
git reset --hard `git log --root --oneline --reverse | head -1 | cut -d' ' -f1`
# Switch test data to upstream ones.
rm -rf test
cp -r ~/repos/Nuitka-references/final/Python-3.11.0/Lib/test test
git add test
# Update commit message to mention proper Python version.
git commit --amend -m "Initial commit of Python tests as in 3.11.0"
# Push to github, setting upstream for branch.
git push -u
# Cherry pick the removal commits from previous branches.
git log origin/CPython310 --reverse --oneline | grep ' Removed' | cut -d' ' -f1 | xargs git cherry-pick
# When being prompted for merge conflicts with the deleted files:
git status | sed -n 's/deleted by them://p' | xargs git rm --ignore-unmatch x ; git cherry-pick --continue
# Push to github, this is useful.
git push
# Cherry pick the first commit of 'run_all.py', the copy it from the last state, and amend the commits.
git log --reverse origin/CPython310 --oneline -- run_all.py | head -1 | cut -d' ' -f1 | xargs git cherry-pick
git checkout origin/CPython310 -- run_all.py
chmod +x run_all.py
sed -i -e 's#python3.10#python3.11#' run_all.py
git commit --amend --no-edit run_all.py
# Same for 'update_doctest_generated.py'
git log --reverse origin/CPython310 --oneline -- update_doctest_generated.py | head -1 | cut -d' ' -f1 | xargs git cherry-pick
git checkout origin/CPython310 -- update_doctest_generated.py
chmod +x update_doctest_generated.py
sed -i -e 's#python3.10#python3.11#' update_doctest_generated.py
git commit --amend --no-edit update_doctest_generated.py
# Same for .gitignore
git log --reverse origin/CPython310 --oneline -- .gitignore | head -1 | cut -d' ' -f1 | xargs git cherry-pick
git checkout origin/CPython310 -- .gitignore
git commit --amend --no-edit .gitignore
# Now cherry-pick all commits of test support, these disable network, audio, GUI, random filenames and more
# and are crucial for deterministic outputs and non-reliance on outside stuff.
git log --reverse origin/CPython310 --oneline -- test/support/__init__.py | tail -n +2 | cut -d' ' -f1 | xargs git cherry-pick
git push
*********************
Design Descriptions
*********************
These should be a lot more and contain graphics from presentations
given. It will be filled in, but not now.
Nuitka Logo
===========
The logo was submitted by "dr. Equivalent". It's source is contained in
``doc/Logo`` where 3 variants of the logo in SVG are placed.
- Symbol only (symbol)
.. code:: rest
.. image:: doc/images/Nuitka-Logo-Symbol.png
:alt: Nuitka Logo
- Text next to symbol (horizontal)
.. code:: rest
.. image:: doc/images/Nuitka-Logo-Horizontal.png
:alt: Nuitka Logo
- Text beneath symbol (vertical)
.. code:: rest
.. image:: doc/images/Nuitka-Logo-Vertical.png
:alt: Nuitka Logo
From these logos, PNG images, and "favicons", and are derived.
The exact ImageMagick commands are in
``nuitka/tools/release/Documentation``, but are not executed each time,
the commands are also replicated here:
.. code:: bash
convert -background none doc/Logo/Nuitka-Logo-Symbol.svg doc/images/Nuitka-Logo-Symbol.png
convert -background none doc/Logo/Nuitka-Logo-Vertical.svg doc/images/Nuitka-Logo-Vertical.png
convert -background none doc/Logo/Nuitka-Logo-Horizontal.svg doc/images/Nuitka-Logo-Horizontal.png
Choice of the Target Language
=============================
- Choosing the target language was important decision. factors were:
- The portability of Nuitka is decided here
- How difficult is it to generate the code?
- Does the Python C-API have bindings?
- Is that language known?
- Does the language aid to find bugs?
The *decision for C11* is ultimately one for portability, general
knowledge of the language and for control over created code, e.g. being
able to edit and try that quickly.
The current status is to use pure C11. All code compiles as C11, and
also in terms of workaround to missing compiler support as C++03. This
is mostly needed, because MSVC does not support C. Naturally we are not
using any C++ features, just the allowances of C++ features that made it
into C11, which is e.g. allowing late definitions of variables.
Use of Scons internally
=======================
Nuitka does not involve Scons in its user interface at all; Scons is
purely used internally. Nuitka itself, being pure Python, will run
without any build process just fine.
Nuitka simply prepares ``<program>.build`` folders with lots of files
and tasks scons to execute the final build, after which Nuitka again
will take control and do more work as necessary.
.. note::
When we speak of "standalone" mode, this is handled outside of Scons,
and after it, creating the ".dist" folder. This is done in
``nuitka.MainControl`` module.
For interfacing to Scons, there is the module
``nuitka.build.SconsInterface`` that will support calling ``scons`` -
potentially from one of two inline copies (one for before / one for
Python 3.5 or later). These are mainly used on Windows or when using
source releases - and passing arguments to it. These arguments are
passed as ``key=value``, and decoded in the scons file of Nuitka.
The scons file is named ``SingleExe.scons`` for lack of better name.
It's really wrong now, but we have yet to find a better name. It once
expressed the intention to be used to create executables, but the same
works for modules too, as in terms of building, and to Scons, things
really are the same.
The scons file supports operation in multiple modes for many things, and
modules is just one of them. It runs outside of Nuitka process scope,
even with a different Python version potentially, so all the information
must be passed on the command line.
What follows is the (lengthy) list of arguments that the scons file
processes:
- ``source_dir``
Where is the generated C source code. Scons will just compile
everything it finds there. No list of files is passed, but instead
this directory is being scanned.
- ``nuitka_src``
Where do the include files and static C parts of Nuitka live. These
provide e.g. the implementation of compiled function, generators, and
other helper codes, this will point to where ``nuitka.build`` package
lives normally.
- ``module_mode``
Build a module instead of a program.
- ``result_base``
This is not a full name, merely the basename for the result to be
produced, but with path included, and the suffix comes from module or
executable mode.
- ``debug_mode``
Enable debug mode, which is a mode, where Nuitka tries to help
identify errors in itself, and will generate less optimal code. This
also asks for warnings, and makes the build fail if there are any.
Scons will pass different compiler options in this case.
- ``python_debug``
Compile and link against Python debug mode, which does assertions and
extra checks, to identify errors, mostly related to reference
counting. May make the build fail, if no debug build library of
CPython is available. On Windows it is possible to install it for
CPython3.5 or higher.
- ``full_compat_mode``
Full compatibility, even where it's stupid, i.e. do not provide
information, even if available, in order to assert maximum
compatibility. Intended to control the level of compatibility to
absurd.
- ``experimental_mode``
Do things that are not yet accepted to be safe.
- ``lto_mode``
Make use of link time optimization of gcc compiler if available and
known good with the compiler in question. So far, this was not found
to make major differences.
- ``disable_console``
Windows subsystem mode: Disable console for windows builds.
- ``unstripped_mode``
Unstripped mode: Do not remove debug symbols.
- ``clang_mode``
Clang compiler mode, default on macOS X and FreeBSD, optional on
Linux.
- ``mingw_mode``
MinGW compiler mode, optional and useful on Windows only.
- ``standalone_mode``
Building a standalone distribution for the binary.
- ``show_scons``
Show scons mode, output information about Scons operation. This will
e.g. also output the actual compiler used, output from compilation
process, and generally debug information relating to be build
process.
- ``python_prefix``
Home of Python to be compiled against, used to locate headers and
libraries.
- ``target_arch``
Target architecture to build. Only meaningful on Windows.
- ``python_version``
The major version of Python built against.
- ``abiflags``
The flags needed for the Python ABI chosen. Might be necessary to
find the folders for Python installations on some systems.
- ``icon_path``
The icon to use for Windows programs if given.
Locating Modules and Packages
=============================
The search for modules used is driven by ``nuitka.importing.Importing``
module.
- Quoting the ``nuitka.importing.Importing`` documentation:
Locating modules and package source on disk.
The actual import of a module would already execute code that changes
things. Imagine a module that does ``os.system()``, it would be done
during compilation. People often connect to databases, and these kind
of things, at import time.
Therefore CPython exhibits the interfaces in an ``imp`` module in
standard library, which one can use those to know ahead of time, what
file import would load. For us unfortunately there is nothing in
CPython that is easily accessible and gives us this functionality for
packages and search paths exactly like CPython does, so we implement
here a multi step search process that is compatible.
This approach is much safer of course and there is no loss. To
determine if it's from the standard library, one can abuse the
attribute ``__file__`` of the ``os`` module like it's done in
``isStandardLibraryPath`` of this module.
End quoting the ``nuitka.importing.Importing`` documentation.
- Role
This module serves the recursion into modules and analysis if a
module is a known one. It will give warnings for modules attempted to
be located, but not found. These warnings are controlled by a while
list inside the module.
The decision making and caching are located in the ``nuitka.tree``
package, in modules ``nuitka.tree.Recursion`` and
``nuitka.tree.ImportCache``. Each module is only considered once (then
cached), and we need to obey lots of user choices, e.g. to compile a
standard library or not.
Hooking for module ``import`` process
=====================================
Currently, in generated code, for every ``import`` a normal
``__import__()`` built-in call is executed. The
``nuitka/build/static_src/MetaPathBasedLoader.c`` file provides the
implementation of a ``sys.meta_path`` hook.
This meta path based importer allows us to have the Nuitka provided
module imported even when imported by non-compiled code.
.. note::
Of course, it would make sense to compile time detect which module it
is that is being imported and then to make it directly. At this time,
we don't have this inter-module optimization yet, mid-term it should
become easy to add.
Supporting ``__class__`` of Python3
===================================
In Python3 the handling of ``__class__`` and ``super`` is different from
Python2. It used to be a normal variable, and now the following things
have changed.
- The use of the ``super`` variable name triggers the addition of a
closure variable ``__class__``, as can be witnessed by the following
code:
.. code:: python
class X:
def f1(self):
print(locals())
def f2(self):
print(locals())
super # Just using the name, not even calling it.
x = X()
x.f1()
x.f2()
Output is:
.. code::
{'self': <__main__.X object at 0x7f1773762390>''} {'self':
<__main__.X object at 0x7f1773762390>, '__class__': <class
'__main__.X'>}
- This value of ``__class__`` is also available in the child functions.
- The parser marks up code objects usage of "super". It doesn't have to
be a call, it can also be a local variable. If the ``super`` built-in
is assigned to another name and that is used without arguments, it
won't work unless ``__class__`` is taken as a closure variable.
- As can be seen in the CPython3 code, the closure value is added after
the class creation is performed.
- It appears, that only functions locally defined to the class are
affected and take the closure.
This left Nuitka with the strange problem, of how to emulate that.
The solution is this:
- Under Python3, usage of ``__class__`` as a reference in a child
function body is mandatory. It remains that way until all variable
names have been resolved.
- When recognizing calls to ``super`` without arguments, make the arguments
into variable reference to ``__class__`` and potentially ``self``
(actually first argument name).
- After all variables have been known, and no suspicious unresolved
calls to anything named ``super`` are down, then unused references
are optimized away by the normal unused closure variable.
- Class dictionary definitions are added.
These are special direct function calls, ready to propagate also
"bases" and "metaclass" values, which need to be calculated outside.
The function bodies used for classes will automatically store
``__class__`` as a shared local variable, if anything uses it. And if
it's not assigned by user code, it doesn't show up in the "locals()"
used for dictionary creation.
Existing ``__class__`` local variable values are in fact provided as
closure, and overridden with the built class , but they should be
used for the closure giving, before the class is finished.
So ``__class__`` will be local variable of the class body, until the
class is built, then it will be the ``__class__`` itself.
Frame Stack
===========
In Python, every function, class, and module has a frame. It is created
when the scope is entered, and there is a stack of these at run time,
which becomes visible in tracebacks in case of exceptions.
The choice of Nuitka is to make this an explicit element of the node
tree, that are as such subject to optimization. In cases, where they are
not needed, they may be removed.
Consider the following code.
.. code:: python
def f():
if someNotRaisingCall():
return somePotentiallyRaisingCall()
else:
return None
In this example, the frame is not needed for all the code, because the
condition checked wouldn't possibly raise at all. The idea is the make
the frame guard explicit and then to reduce its scope whenever possible.
So we start out with code like this one:
.. code:: python
def f():
with frame_guard("f"):
if someNotRaisingCall():
return somePotentiallyRaisingCall()
else:
return None
This is to be optimized into:
.. code:: python
def f():
if someNotRaisingCall():
with frame_guard("f"):
return somePotentiallyRaisingCall()
else:
return None
Notice how the frame guard taking is limited and may be avoided, or in
best cases, it might be removed completely. Also this will play a role
when in-lining function. The frame stack entry will then be
automatically preserved without extra care.
.. note::
In the actual code, ``nuitka.nodes.FrameNodes.StatementsFrame`` is
represents this as a set of statements to be guarded by a frame
presence.
Parameter Parsing
=================
The parsing of parameters is very convoluted in Python, and doing it in
a compatible way is not that easy. This is a description of the required
process, for an easier overview.
Input
-----
The input is an argument ``tuple`` (the type is fixed), which contains
the positional arguments, and potentially an argument ``dict`` (type is
fixed as well, but could also be ``NULL``, indicating that there are no
keyword arguments.
Keyword dictionary
------------------
The keyword argument dictionary is checked first. Anything in there,
that cannot be associated, either raise an error, or is added to a
potentially given star dict argument. So there are two major cases.
- No star dict argument: Iterate over dictionary, and assign or raise
errors.
This check covers extra arguments given.
- With star dict argument: Iterate over dictionary, and assign or raise
errors.
Interesting case for optimization are no positional arguments, then
no check is needed, and the keyword argument dictionary could be used
as the star argument. Should it change, a copy is needed though.
What's noteworthy here, is that in comparison to the keywords, we can
hope that they are the same value as we use. The interning of strings
increases chances for non-compiled code to do that, esp. for short
names.
We then can do a simple ``is`` comparison and only fall back to real
string ``==`` comparisons, after all of these failed. That means more
code, but also a lot faster code in the positive case.
Argument tuple
--------------
After this completed, the argument tuple is up for processing. The first
thing it needs to do is to check if it's too many of them, and then to
complain.
For arguments in Python2, there is the possibility of them being nested,
in which case they cannot be provided in the keyword dictionary, and
merely should get picked from the argument tuple.
Otherwise, the length of the argument tuple should be checked against
its position and if possible, values should be taken from there. If it's
already set (from the keyword dictionary), raise an error instead.
SSA form for Nuitka
===================
The SSA form is critical to how optimization works. The so called trace
collections builds up traces. These are facts about how this works:
- Assignments draw from a counter unique for the variable, which
becomes the variable version. This happens during tree building
phase.
- References are associated with the version of the variable active.
This can be a merge of branches. Trace collection does do that and
provides nodes with the currently active trace for a variable.
The data structures used for trace collection need to be relatively
compact as the trace information can become easily much more data than
the program itself.
Every trace collection has these:
- variable_actives
Dictionary, where per "variable" the currently used version is. Used
to track situations changes in branches. This is the main input for
merge process.
- variable_traces
Dictionary, where "variable" and "version" form the key. The values
are objects with or without an assignment, and a list of usages,
which starts out empty.
These objects have usages appended to them. In "onVariableSet", a new
version is allocated, which gives a new object for the dictionary,
with an empty usages list, because each write starts a new version.
In "onVariableUsage" the version is detected from the current
version. It may be not set yet, which means, it's a read of an
undefined value (local variable, not a parameter name), or unknown in
case of global variable.
These objects may be told that their value has escaped. This should
influence the value friend they attached to the initial assignment.
Each usage may have a current value friend state that is different.
When merging branches of conditional statements, the merge shall apply
as follows:
- Branches have their own collection
Thee have potentially deviating sets of ``variable_actives``. These
are children of an outer collections.
- Case a) One branch only.
For that branch a collection is performed. As usual new assignments
generate a new version making it "active", references then related to
these "active" versions.
Then, when the branch is merged, for all "active" variables, it is
considered, if that is a change related to before the branch. If it's
not the same, a merge trace with the branch condition is created with
the one active in the collection before that statement.
- Case b) Two branches.
When there are two branches, they both as are treated as above,
except for the merge.
When merging, a difference in active variables between the two
branches creates the merge trace.
.. note::
For conditional expressions, there are always only two branches. Even
if you think you have more than one branch, you do not. It's always
nested branches, already when it comes out of the ``ast`` parser.
Trace structure, there are different kinds of traces.
- Initial write of the version
There may be an initial write for each version. It can only occur at
the start of the scope, but not later, and there is only one. This
might be known to be "initialized" (parameter variables of functions
are like that) or "uninitialized", or "unknown".
- Merge of other one or two other versions
This combines two or more previous versions. In cases of loop exits
or entries, there are multiple branches to combine potentially. These
branches can have vastly different properties.
- Becoming unknown.
When control flow escapes, e.g. for a module variable, any write can
occur to it, and it's value cannot be trusted to be unchanged. These
are then traced as unknown.
All traces have a base class ``ValueTraceBase`` which provides the
interface to query facts about the state of a variable in that trace.
It's e.g. of some interest, if a variable must have a value or must not.
This allows to e.g. omit checks, know what exceptions might raise.
Loop SSA
========
For loops we have the addition difficulty that we need would need to
look ahead what types a variable has at loop exit, but that is a cyclic
dependency.
Our solution is to consider the variable types at loop entry. When these
change, we drop all gained information from inside the loop. We may e.g.
think that a variable is a ``int`` or ``float``, but later recognize
that it can only be a float. Derivations from ``int`` must be discarded,
and the loop analysis restarted.
Then during the loop, we assign an incomplete loop trace shape to the
variable, which e.g. says it was an ``int`` initially and additional
type shapes, e.g. ``int or long`` are then derived. If at the end of the
loop, a type produced no new types, we know we are finished and mark the
trace as a complete loop trace.
If it is not, and next time, we have the same initial types, we add the
ones derived from this to the starting values, and see if this gives
more types.
Python Slots in Optimization
============================
Basic Slot Idea
---------------
For almost all the operations in Python, a form of overloading is
available. That is what makes it so powerful.
So when you write an expression like this one:
.. code:: python
1.0 + something
This something will not just blindly work when it's a float, but go
through a slot mechanism, which then can be overloaded.
.. code:: python
class SomeStrangeFloat:
def __float__(self):
return 3.14
something = SomeStrangeFloat()
# ...
1.0 + float(something) // 4.140000000000001
Here it is the case, that this is used by user code, but more often this
is used internally. Not all types have all slots, e.g. ``list`` does not
have ``__float__`` and therefore will refuse an addition to a ``float``
value, based on that.
Another slot is working here, that we didn't mention yet, and that is
``__add__`` which for some times will be these kinds of conversions or
it will not do that kind of thing, e.g. something do hard checks, which
is why this fails to work:
.. code:: python
[] + ()
As a deliberate choice, there is no ``__list__`` slot used. The Python
designers are aiming at solving many things with slots, but they also
accept limitations.
There are many slots that are frequently used, most often behind your
back (``__iter__``, ``__next__``, ``__lt__``, etc.). The list is large,
and tends to grow with Python releases, but it is not endless.
Representation in Nuitka
------------------------
So a slot in Nuitka typically has an owning node. We use ``__len__`` as
an example here. In the ``computeExpression`` the ``len`` node named
``ExpressionBuiltinLen`` has to defer the decision what it computes to
its argument.
.. code:: python
def computeExpression(self, trace_collection):
return self.subnode_value.computeExpressionLen(
len_node=self, trace_collection=trace_collection
)
That decision then, in the absence of any type knowledge, must be done
absolutely carefully and conservative, as could see anything executing
here.
That examples this code in ``ExpressionBase`` which every expression by
default uses:
.. code:: python
def computeExpressionLen(self, len_node, trace_collection):
shape = self.getValueShape()
has_len = shape.hasShapeSlotLen()
if has_len is False:
return makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue(
template="object of type '%s' has no len()",
operation="len",
original_node=len_node,
value_node=self,
)
elif has_len is True:
iter_length = self.getIterationLength()
if iter_length is not None:
from .ConstantRefNodes import makeConstantRefNode
result = makeConstantRefNode(
constant=int(iter_length), # make sure to downcast long
source_ref=len_node.getSourceReference(),
)
result = wrapExpressionWithNodeSideEffects(new_node=result, old_node=self)
return (
result,
"new_constant",
"Predicted 'len' result from value shape.",
)
self.onContentEscapes(trace_collection)
# Any code could be run, note that.
trace_collection.onControlFlowEscape(self)
# Any exception may be raised.
trace_collection.onExceptionRaiseExit(BaseException)
return len_node, None, None
Notice how by default, known ``__len__`` but unpredictable or even
unknown if a ``__len__`` slot is there, the code indicates that its
contents and the control flow escapes (could change things behind out
back) and any exception could happen.
Other expressions can know better, e.g. for compile time constants we
can be a whole lot more certain:
.. code:: python
def computeExpressionLen(self, len_node, trace_collection):
return trace_collection.getCompileTimeComputationResult(
node=len_node,
computation=lambda: len(self.getCompileTimeConstant()),
description="""Compile time constant len value pre-computed.""",
)
In this case, we are using a function that will produce a concrete value
or the exception that the ``computation`` function raised. In this case,
we can let the Python interpreter that runs Nuitka do all the hard work.
This lives in ``CompileTimeConstantExpressionBase`` and is the base for
all kinds of constant values, or even built-in references like the name
``len`` itself and would be used in case of doing ``len(len)`` which
obviously gives an exception.
Other overloads do not currently exist in Nuitka, but through the
iteration length, most cases could be addressed, e.g. ``list`` nodes
typical know their element counts.
The C side
==========
When a slot is not optimized away at compile time however, we need to
generate actual code for it. We figure out what this could be by looking
at the original CPython implementation.
.. code:: C
PyObject *builtin_len(PyObject *self, PyObject *v) {
Py_ssize_t res;
res = PyObject_Size(v);
if (res < 0 && PyErr_Occurred())
return NULL;
return PyInt_FromSsize_t(res);
}
We find a pointer to ``PyObject_Size`` which is a generic Python C/API
function used in the ``builtin_len`` implementation:
.. code:: C
Py_ssize_t PyObject_Size(PyObject *o) {
PySequenceMethods *m;
if (o == NULL) {
null_error();
return -1;
}
m = o->ob_type->tp_as_sequence;
if (m && m->sq_length)
return m->sq_length(o);
return PyMapping_Size(o);
}
On the C level, every Python object (the ``PyObject *``) as a type named
``ob_type`` and most of its elements are slots. Sometimes they form a
group, here ``tp_as_sequence`` and then it may or may not contain a
function. This one is tried in preference. Then, if that fails, next up
the mapping size is tried.
.. code:: C
Py_ssize_t PyMapping_Size(PyObject *o) {
PyMappingMethods *m;
if (o == NULL) {
null_error();
return -1;
}
m = o->ob_type->tp_as_mapping;
if (m && m->mp_length)
return m->mp_length(o);
type_error("object of type '%.200s' has no len()", o);
return -1;
}
This is the same principle, except with ``tp_as_mapping`` and
``mp_length`` used.
So from this, we can tell how ``len`` gets at what could be a Python
class ``__len__`` or other built-in types.
In principle, every slot needs to be dealt with in Nuitka, and it is
assumed that currently all slots are supported on at least a very
defensive level, to avoid unnoticed escapes of control flow.
Built-in call optimization
==========================
For calls to built-in names, there is typically a function in Python
that delegates to the type constructor (e.g. when we talk about ``int``
that just creates an object passing the arguments of the call) or its
own special implementation as we saw with the ``len``.
For each built-in called, we have a specialized node, that presents to
optimization the actions of the built-in. What are the impact, what are
the results. We have seen the resulting example for ``len`` above, but
how do we get there.
In Python, built-in names are used only if there is no module level
variable of the name, and of course no local variable of that name.
Therefore, optimization of a built-in name is only done if it turns out
the actually assigned in other code, and then when the call comes,
arguments are checked and a relatively static node is created.
Code Generation towards C
=========================
Currently, Nuitka uses Pure C and no C++ patterns at all. The use of C11
requires on some platforms to compile the C11 using a C++ compiler,
which works relatively well, but also limits the amount of C11 that can
be used.
Exceptions
----------
To handle and work with exceptions, every construct that can raise has
either a ``bool`` or ``int`` return code or ``PyObject *`` with ``NULL``
return value. This is very much in line with that the Python C-API does.
Every helper function that contains code that might raise needs these
variables. After a failed call, our variant of ``PyErr_Fetch`` called
``FETCH_ERROR_OCCURRED_STATE`` must be used to catch the defined error,
unless some quick exception cases apply. The quick exception means,
``NULL`` return from C-API without a set exception means e.g.
``StopIteration``.
As an optimization, functions that raise exceptions, but are known not
to do so, for whatever reason, could only be asserted to not do so.
Statement Temporary Variables
-----------------------------
For statements and larger constructs the context object track temporary
values, that represent references. For some, these should be released at
the end of the statement, or they represent a leak.
The larger scope temporary variables, are tracked in the function or
module context, where they are supposed to have explicit ``del`` to
release their references.
Local Variables Storage
-----------------------
Closure variables taken are to be released when the function object is
later destroyed. For in-lined calls, variables are just passed, and it
does not become an issue to release anything.
For function exit, owned variables, local or shared to other functions,
must be released. This cannot be a ``del`` operation, as it also
involves setting a value, which would be wrong for shared variables (and
wasteful to local variables, as that would be its last usage). Therefore
we need a special operation that simply releases the reference to the
cell or object variable.
Exit Targets
------------
Each error or other exit releases statement temporary values and then
executes a ``goto`` to the exit target. These targets need to be setup.
The ``try``/``except`` will e.g. catch error exits.
Other exits are ``continue``, ``break``, and ``return`` exits. They all
work alike.
Generally, the exits stack of with constructs that need to register
themselves for some exit types. A loop e.g. registers the ``continue``
exit, and a contained ``try``/``finally`` too, so it can execute the
final code should it be needed.
Frames
------
Frames are containers for variable declarations and cleanups. As such,
frames provide error exits and success exits, which remove the frame
from the frame stack, and then proceed to the parent exit.
With the use of non ``PyObject **`` C types, but frame exception exits,
the need to convert those types becomes apparent. Exceptions should
still resolve the C version. When using different C types at frame
exception exits, there is a need to trace the active type, so it can be
used in the correct form.
Abortive Statements
-------------------
The way ``try``/``finally`` is handled, copies of the ``finally`` block
are made, and optimized independently for each abort method. The ones
there are of course, ``return``, ``continue``, and ``break``, but also
implicit and explicit ``raise`` of an exception.
Code trailing an abortive statement can be discarded, and the control
flow will follow these "exits".
Constant Preparation
====================
Early versions of Nuitka, created all constants for the whole program
for ready access to generated code, before the program launches. It did
so in a single file, but that approach didn't scale well.
Problems were
- Even unused code contributed to start-up time, this can become a lot
for large programs, especially in standalone mode.
- The massive amount of constant creation codes gave backend C
compilers a much harder time than necessary to analyse it all at
once.
The current approach is as follows. Code generation detects constants
used in only one module, and declared ``static`` there, if the module is
the only user, or ``extern`` if it is not. Some values are forced to be
global, as they are used pre-main or in helpers.
These ``extern`` values are globally created before anything is used.
The ``static`` values are created when the module is loaded, i.e.
something did import it.
We trace used constants per module, and for nested ones, we also
associate them. The global constants code is special in that it can only
use ``static`` for nested values it exclusively uses, and has to export
values that others use.
Language Conversions to make things simpler
===========================================
There are some cases, where the Python language has things that can in
fact be expressed in a simpler or more general way, and where we choose
to do that at either tree building or optimization time.
The ``assert`` statement
------------------------
The ``assert`` statement is a special statement in Python, allowed by
the syntax. It has two forms, with and without a second argument. The
later is probably less known, as is the fact that raise statements can
have multiple arguments too.
The handling in Nuitka is:
.. code:: python
assert value
# Absolutely the same as:
if not value:
raise AssertionError
.. code:: python
assert value, raise_arg
# Absolutely the same as:
if not value:
raise AssertionError(raise_arg)
This makes assertions absolutely the same as a raise exception in a
conditional statement.
This transformation is performed at tree building already, so Nuitka
never knows about ``assert`` as an element and standard optimizations
apply. If e.g. the truth value of the assertion can be predicted, the
conditional statement will have the branch statically executed or
removed.
The "comparison chain" expressions
----------------------------------
In Nuitka we have the concept of an outline, and therefore we can make
the following re-formulation instead:
.. code:: python
a < b() > c < d
def _comparison_chain(): # So called "outline" function
tmp_a = a
tmp_b = b()
tmp = tmp_a < tmp_b
if not tmp:
return tmp
del tmp_a
tmp_c = c
tmp = tmp_b > tmp_c
if not tmp:
return tmp
del tmp_b
return tmp_c < d
_comparison_chain()
This transformation is performed at tree building already. The temporary
variables keep the value for the use of the same expression. Only the
last expression needs no temporary variable to keep it.
What we got from this, is making the checks of the comparison chain
explicit and comparisons in Nuitka to be internally always about two
operands only.
The ``execfile`` built-in
-------------------------
Handling is:
.. code:: python
execfile(filename)
# Basically the same as:
exec(compile(open(filename).read()), filename, "exec")
.. note::
This allows optimizations to discover the file opening nature easily
and apply file embedding or whatever we will have there one day.
This transformation is performed when the ``execfile`` built-in is
detected as such during optimization.
Generator expressions with ``yield``
------------------------------------
These are converted at tree building time into a generator function body
that yields from the iterator given, which is the put into a for loop to
iterate, created a lambda function of and then called with the first
iterator.
That eliminates the generator expression for this case. It's a bizarre
construct and with this trick needs no special code generation.
This is a complex example, demonstrating multiple cases of yield in
unexpected cases:
.. code:: python
x = ((yield i) for i in (1, 2) if not (yield))
# Basically the same as:
def x():
for i in (1, 2):
if not (yield):
yield (yield i)
Function Decorators
-------------------
When one learns about decorators, you see that:
.. code:: python
@decorator
def function():
pass
# Is basically the same as:
def function():
pass
function = decorator(function)
The only difference is the assignment to function. In the ``@decorator``
case, if the decorator fails with an exception, the name ``function`` is
not assigned yet, but kept in a temporary variable.
Therefore in Nuitka this assignment is more similar to that of a lambda
expression, where the assignment to the name is only at the end, which
also has the extra benefit of not treating real function and lambda
functions any different.
This removes the need for optimization and code generation to support
decorators at all. And it should make the two variants optimize equally
well.
Functions nested arguments
--------------------------
Nested arguments are a Python2 only feature supported by Nuitka.
Consider this example:
.. code:: python
def function(a, (b, c)):
return a, b, c
We solve this, by kind of wrapping the function with another function
that does the unpacking and gives the errors that come from this:
.. code:: python
def function(a, _1):
def _tmp(a, b, c):
return a, b, c
a, b = _1
return _tmp(a, b, c)
The ``.1`` is the variable name used by CPython internally, and actually
works if you use keyword arguments via star dictionary. So this is very
compatible and actually the right kind of re-formulation, but it removes
the need from the code that does parameter parsing to deal with these.
Obviously, there is no frame for ``_tmp``, just one for ``function`` and
we do not use local variables, but temporary functions.
In-place Assignments
--------------------
In-place assignments are re-formulated to an expression using temporary
variables.
These are not as much a reformulation of ``+=`` to ``+``, but instead
one which makes it explicit that the assign target may change its value.
.. code:: python
a += b
.. code:: python
_tmp = a.__iadd__(b)
if a is not _tmp:
a = _tmp
Using ``__iadd__`` here to express that for the ``+``, the in-place
variant ``iadd`` is used instead. The ``is`` check may be optimized away
depending on type and value knowledge later on.
Complex Assignments
-------------------
Complex assignments are defined as those with multiple targets to assign
from a single source and are re-formulated to such using a temporary
variable and multiple simple assignments instead.
.. code:: python
a = b = c
.. code:: python
_tmp = c
a = _tmp
b = _tmp
del _tmp
This is possible, because in Python, if one assignment fails, it can
just be interrupted, so in fact, they are sequential, and all that is
required is to not calculate ``c`` twice, which the temporary variable
takes care of. Were ``b`` a more complex expression, e.g.
``b.some_attribute`` that might raise an exception, ``a`` would still be
assigned.
Unpacking Assignments
---------------------
Unpacking assignments are re-formulated to use temporary variables as
well.
.. code:: python
a, b.attr, c[ind] = d = e, f, g = h()
Becomes this:
.. code:: python
_tmp = h()
_iter1 = iter(_tmp)
_tmp1 = unpack(_iter1, 3)
_tmp2 = unpack(_iter1, 3)
_tmp3 = unpack(_iter1, 3)
unpack_check(_iter1)
a = _tmp1
b.attr = _tmp2
c[ind] = _tmp3
d = _tmp
_iter2 = iter(_tmp)
_tmp4 = unpack(_iter2, 3)
_tmp5 = unpack(_iter2, 3)
_tmp6 = unpack(_iter2, 3)
unpack_check(_iter1)
e = _tmp4
f = _tmp5
g = _tmp6
That way, the unpacking is decomposed into multiple simple statements.
It will be the job of optimizations to try and remove unnecessary
unpacking, in case e.g. the source is a known tuple or list creation.
.. note::
The ``unpack`` is a special node which is a form of ``next`` that
will raise a ``ValueError`` when it cannot get the next value, rather
than a ``StopIteration``. The message text contains the number of
values to unpack, therefore the integer argument.
.. note::
The ``unpack_check`` is a special node that raises a ``ValueError``
exception if the iterator is not finished, i.e. there are more values
to unpack. Again the number of values to unpack is provided to
construct the error message.
With Statements
---------------
The ``with`` statements are re-formulated to use temporary variables as
well. The taking and calling of ``__enter__`` and ``__exit__`` with
arguments, is presented with standard operations instead. The promise to
call ``__exit__`` is fulfilled by ``try``/``except`` clause instead.
.. code:: python
with some_context as x:
something(x)
.. code:: python
tmp_source = some_context
# Actually it needs to be "special look-up" for Python2.7, so attribute
# look-up won't be exactly what is there.
tmp_exit = tmp_source.__exit__
# This one must be held for the whole with statement, it may be assigned
# or not, in our example it is. If an exception occurs when calling
# ``__enter__``, the ``__exit__`` should not be called.
tmp_enter_result = tmp_source.__enter__()
# Indicator variable to know if "tmp_exit" has been called.
tmp_indicator = False
try:
# Now the assignment is to be done, if there is any name for the
# manager given, this may become multiple assignment statements and
# even unpacking ones.
x = tmp_enter_result
# Then the code of the "with" block.
something(x)
except Exception:
# Note: This part of the code must not set line numbers, which we
# indicate with special source code references, which we call "internal".
# Otherwise the line of the frame would get corrupted.
tmp_indicator = True
if not tmp_exit(*sys.exc_info()):
raise
finally:
if not tmp_indicator:
# Call the exit if no exception occurred with all arguments
# as "None".
tmp_exit(None, None, None)
.. note::
We don't refer really to ``sys.exc_info()`` at all, instead, we have
fast references to the current exception type, value and trace, taken
directly from the caught exception object on the C level.
If we had the ability to optimize ``sys.exc_info()`` to do that, we
could use the same transformation, but right now we don't have it.
For Loops
---------
The ``for`` loops use normal assignments and handle the iterator that is
implicit in the code explicitly.
.. code:: python
for x, y in iterable:
if something(x):
break
else:
otherwise()
This is roughly equivalent to the following code:
.. code:: python
_iter = iter(iterable)
_no_break_indicator = False
while 1:
try:
_tmp_value = next(_iter)
except StopIteration:
# Set the indicator that the else branch may be executed.
_no_break_indicator = True
# Optimization should be able to tell that the else branch is run
# only once.
break
# Normal assignment re-formulation applies to this assignment of course.
x, y = _tmp_value
del _tmp_value
if something(x):
break
if _no_break_indicator:
otherwise()
.. note::
The ``_iter`` temporary variable is of course also in a
``try/finally`` construct, to make sure it releases after its used.
The ``x, y`` assignment is of course subject to unpacking
re-formulation.
The ``try``/``except`` is detected to allow to use a variant of
``next`` that does not raise an exception, but to be fast check about
the ``NULL`` return from ``next`` built-in. So no actual exception
handling is happening in this case.
While Loops
-----------
Quoting the ``nuitka.tree.ReformulationWhileLoopStatements``
documentation:
Reformulation of while loop statements.
Loops in Nuitka have no condition attached anymore, so while loops are
re-formulated like this:
.. code:: python
while condition:
something()
.. code:: python
while 1:
if not condition:
break
something()
This is to totally remove the specialization of loops, with the
condition moved to the loop body in an initial conditional statement,
which contains a ``break`` statement.
That achieves, that only ``break`` statements exit the loop, and allow
for optimization to remove always true loop conditions, without
concerning code generation about it, and to detect such a situation,
consider e.g. endless loops.
.. note::
Loop analysis (not yet done) can then work on a reduced problem
(which ``break`` statements are executed under what conditions) and
is then automatically very general.
The fact that the loop body may not be entered at all, is still
optimized, but also in the general sense. Explicit breaks at the loop
start and loop conditions are the same.
End quoting the ``nuitka.tree.ReformulationWhileLoopStatements``
documentation:
Exception Handlers
------------------
Exception handlers in Python may assign the caught exception value to a
variable in the handler definition. And the different handlers are
represented as conditional checks on the result of comparison
operations.
.. code:: python
try:
block()
except A as e:
handlerA(e)
except B as e:
handlerB(e)
else:
handlerElse()
.. code:: python
try:
block()
except:
# These are special nodes that access the exception, and don't really
# use the "sys" module.
tmp_exc_type = sys.exc_info()[0]
tmp_exc_value = sys.exc_info()[1]
# exception_matches is a comparison operation, also a special node.
if exception_matches(tmp_exc_type, (A,)):
e = tmp_exc_value
handlerA(e)
elif exception_matches(tmp_exc_type, (B,)):
e = tmp_exc_value
handlerB(e)
else:
handlerElse()
For Python3, the assigned ``e`` variables get deleted at the end of the
handler block. Should that value be already deleted, that ``del`` does
not raise, therefore it's tolerant. This has to be done in any case, so
for Python3 it is even more complex.
.. code:: python
try:
block()
except:
# These are special nodes that access the exception, and don't really
# use the "sys" module.
tmp_exc_type = sys.exc_info()[0]
tmp_exc_value = sys.exc_info()[1]
# exception_matches is a comparison operation, also a special node.
if exception_matches(tmp_exc_type, (A,)):
try:
e = tmp_exc_value
handlerA(e)
finally:
del e
elif exception_matches(tmp_exc_type, (B,)):
try:
e = tmp_exc_value
handlerB(e)
finally:
del e
else:
handlerElse()
Should there be no ``else:`` branch, a default re-raise statement is
used instead.
And of course, the values of the current exception type and value, both
use special references, that access the C++ and don't go via
``sys.exc_info`` at all, nodes called ``CaughtExceptionTypeRef`` and
``CaughtExceptionValueRef``.
This means, that the different handlers and their catching run time
behavior are all explicit and reduced the branches.
Statement ``try``/``except`` with ``else``
------------------------------------------
Much like ``else`` branches of loops, an indicator variable is used to
indicate the entry into any of the exception handlers.
Therefore, the ``else`` becomes a real conditional statement in the node
tree, checking the indicator variable and guarding the execution of the
``else`` branch.
Class Creation (Python2)
------------------------
Classes in Python2 have a body that only serves to build the class
dictionary and is a normal function otherwise. This is expressed with
the following re-formulation:
.. code:: python
# in module "SomeModule"
# ...
class SomeClass(SomeBase, AnotherBase):
""" This is the class documentation. """
some_member = 3
.. code:: python
def _makeSomeClass():
# The module name becomes a normal local variable too.
__module__ = "SomeModule"
# The doc string becomes a normal local variable.
__doc__ = """ This is the class documentation. """
some_member = 3
return locals()
# force locals to be a writable dictionary, will be optimized away, but
# that property will stick. This is only to express, that locals(), where
# used will be writable to.
exec("")
SomeClass = make_class("SomeClass", (SomeBase, AnotherBase), _makeSomeClass())
That is roughly the same, except that ``_makeSomeClass`` is *not*
visible to its child functions when it comes to closure taking, which we
cannot express in Python language at all.
Therefore, class bodies are just special function bodies that create a
dictionary for use in class creation. They don't really appear after the
tree building stage anymore. The type inference will of course have to
become able to understand ``make_class`` quite well, so it can recognize
the created class again.
Class Creation (Python3)
------------------------
In Python3, classes are a complicated way to write a function call, that
can interact with its body. The body starts with a dictionary provided
by the metaclass, so that is different, because it can ``__prepare__`` a
non-empty locals for it, which is hidden away in "prepare_class_dict"
below.
What's noteworthy, is that this dictionary, could e.g. be an
``OrderDict``. I am not sure, what ``__prepare__`` is allowed to return.
.. code:: python3
# in module "SomeModule"
# ...
class SomeClass(SomeBase, AnotherBase, metaclass = SomeMetaClass):
""" This is the class documentation. """
some_member = 3
.. code:: python
# Non-keyword arguments, need to be evaluated first.
tmp_bases = (SomeBase, AnotherBase)
# Keyword arguments go next, __metaclass__ is just one of them. In principle
# we need to forward the others as well, but this is ignored for the sake of
# brevity.
tmp_metaclass = select_metaclass(tmp_bases, SomeMetaClass)
tmp_prepared = tmp_metaclass.__prepare__("SomeClass", tmp_bases)
# The function that creates the class dictionary. Receives temporary variables
# to work with.
def _makeSomeClass():
# This has effect, currently I don't know how to express that in Python3
# syntax, but we will have a node that does that.
locals().replace(tmp_prepared)
# The module name becomes a normal local variable too.
__module__ = "SomeModule"
# The doc string becomes a normal local variable.
__doc__ = """ This is the class documentation. """
some_member = 3
# Create the class, share the potential closure variable "__class__"
# with others.
__class__ = tmp_metaclass("SomeClass", tmp_bases, locals())
return __class__
# Build and assign the class.
SomeClass = _makeSomeClass()
Generator Expressions
---------------------
There are re-formulated as functions.
Generally they are turned into calls of function bodies with
(potentially nested) for loops:
.. code:: python
gen = (x * 2 for x in range(8) if cond())
.. code:: python
def _gen_helper(__iterator):
for x in __iterator:
if cond():
yield x * 2
gen = _gen_helper(range(8))
List Contractions
-----------------
The list contractions of Python2 are different from those of Python3, in
that they don't actually do any closure variable taking, and that no
function object ever exists.
.. code:: python
list_value = [x * 2 for x in range(8) if cond()]
.. code:: python
def _listcontr_helper(__iterator):
result = []
for x in __iterator:
if cond():
result.append(x * 2)
return result
list_value = _listcontr_helper(range(8))
The difference is that with Python3, the function "_listcontr_helper" is
really there and named ``<listcontraction>`` (or ``<listcomp>`` as of
Python3.7 or higher), whereas with Python2 the function is only an
outline, so it can readily access the containing name space.
Set Contractions
----------------
The set contractions of Python2.7 are like list contractions in Python3,
in that they produce an actual helper function:
.. code:: python
set_value = {x * 2 for x in range(8) if cond()}
.. code:: python
def _setcontr_helper(__iterator):
result = set()
for x in __iterator:
if cond():
result.add(x * 2)
return result
set_value = _setcontr_helper(range(8))
Dictionary Contractions
-----------------------
The dictionary contractions of are like list contractions in Python3, in
that they produce an actual helper function:
.. code:: python
dict_value = {x: x * 2 for x in range(8) if cond()}
.. code:: python
def _dictcontr_helper(__iterator):
result = {}
for x in __iterator:
if cond():
result[x] = x * 2
return result
set_value = _dictcontr_helper(range(8))
Boolean expressions ``and`` and ``or``
--------------------------------------
The short circuit operators ``or`` and ``and`` tend to be only less
general that the ``if``/``else`` expressions, but have dedicated nodes.
We used to have a re-formulation towards those, but we now do these via
dedicated nodes too.
These new nodes, present the evaluation of the left value, checking for
its truth value, and depending on it, to pick it, or use the right
value.
Simple Calls
------------
As seen below, even complex calls are simple calls. In simple calls of
Python there is still some hidden semantic going on, that we expose.
.. code:: python
func(arg1, arg2, named1=arg3, named2=arg4)
On the C-API level there is a tuple and dictionary built. This one is
exposed:
.. code:: python
func(*(arg1, arg2), **{"named1": arg3, "named2": arg4})
A called function will access this tuple and the dictionary to parse the
arguments, once that is also re-formulated (argument parsing), it can
then lead to simple in-lining. This way calls only have 2 arguments with
constant semantics, that fits perfectly with the C-API where it is the
same, so it is actually easier for code generation.
Although the above looks like a complex call, it actually is not. No
checks are needed for the types of the star arguments and it's directly
translated to ``PyObject_Call``.
Complex Calls
-------------
The call operator in Python allows to provide arguments in 4 forms.
- Positional (or normal) arguments
- Named (or keyword) arguments
- Star list arguments
- Star dictionary arguments
The evaluation order is precisely that. An example would be:
.. code:: python
something(pos1, pos2, name1=named1, name2=named2, *star_list, **star_dict)
The task here is that first all the arguments are evaluated, left to
right, and then they are merged into only two, that is positional and
named arguments only. for this, the star list argument and the star
dictionary arguments, are merged with the positional and named
arguments.
What's peculiar, is that if both the star list and dictionary arguments
are present, the merging is first done for star dictionary, and only
after that for the star list argument. This makes a difference, because
in case of an error, the star argument raises first.
.. code:: python
something(*1, **2)
This raises "TypeError: something() argument after ** must be a mapping,
not int" as opposed to a possibly more expected "TypeError: something()
argument after * must be a sequence, not int."
That doesn't matter much though, because the value is to be evaluated
first anyway, and the check is only performed afterwards. If the star
list argument calculation gives an error, this one is raised before
checking the star dictionary argument.
So, what we do, is we convert complex calls by the way of special
functions, which handle the dirty work for us. The optimization is then
tasked to do the difficult stuff. Our example becomes this:
.. code:: python
def _complex_call(called, pos, kw, star_list_arg, star_dict_arg):
# Raises errors in case of duplicate arguments or tmp_star_dict not
# being a mapping.
tmp_merged_dict = merge_star_dict_arguments(
called, tmp_named, mapping_check(called, tmp_star_dict)
)
# Raises an error if tmp_star_list is not a sequence.
tmp_pos_merged = merge_pos_arguments(called, tmp_pos, tmp_star_list)
# On the C-API level, this is what it looks like.
return called(*tmp_pos_merged, **tmp_merged_dict)
returned = _complex_call(
called=something,
pos=(pos1, pos2),
named={"name1": named1, "name2": named2},
star_list_arg=star_list,
star_dict_arg=star_dict,
)
The call to ``_complex_call`` is be a direct function call with no
parameter parsing overhead. And the call in its end, is a special call
operation, which relates to the ``PyObject_Call`` C-API.
Assignment Expressions
----------------------
In Python 3.8 or higher, you assign inside expressions.
.. code:: python
if (x := cond()):
do_something()
this is the same as:
.. code:: python
# Doesn't exist with that name, and it is not really taking closure variables,
# it just shares the execution context.
def _outline_func():
nonlocal x
x = cond()
return x
if (_outline_func()):
do_something
When we use this outline function, we are allowed statements, even
assignments, in expressions. For optimization, they of course pose a
challenge to be removed ever, only happens when it becomes only a return
statement, but they do not cause much difficulties for code generation,
since they are transparent.
Match Statements
----------------
In Python 3.10 or higher, you can write so called ``match`` statements
like this:
.. code:: python
match something():
case [x] if x:
z = 2
case _ as y if y == x and y:
z = 1
case 0:
z = 0
This is the same as
.. code:: python
tmp_match_subject = something()
# Indicator variable, once true, all matching stops.
tmp_handled = False
# First branch
x = tmp_match_subject
if sequence_check(x)
if x:
z = 2
tmp_handled = True
if tmp_handled is False:
y = tmp_match_subject
if x == y and y:
z = 1
tmp_handled = True
if tmp_handled is False:
z = 0
Print Statements
----------------
The ``print`` statement exists only in Python2. It implicitly converts
its arguments to strings before printing them. In order to make this
accessible and compile time optimized, this is made visible in the node
tree.
.. code:: python
print arg1, "1", 1
This is in Nuitka converted so that the code generation for ``print``
doesn't do any conversions itself anymore and relies on the string
nature of its input.
.. code:: python
print str(arg1), "1", str(1)
Only string objects are spared from the ``str`` built-in wrapper,
because that would only cause noise in optimization stage. Later
optimization can then find it unnecessary for certain arguments.
Additionally, each ``print`` may have a target, and multiple arguments,
which we break down as well for dumber code generation. The target is
evaluated first and should be a file, kept referenced throughout the
whole print statement.
.. code:: python
print >> target_file, str(arg1), "1", str(1)
This is being reformulated to:
.. code:: python
try:
tmp_target = target_file
print >>tmp_target, str(arg1), print >>tmp_target, "1", print
>>tmp_target, str(1), print >>tmp_target
finally:
del tmp_target
This allows code generation to not deal with arbitrary amount of
arguments to ``print``. It also separates the newline indicator from the
rest of things, which makes sense too, having it as a special node, as
it's behavior with regards to soft-space is different of course.
And finally, for ``print`` without a target, we still assume that a
target was given, which would be ``sys.stdout`` in a rather hard-coded
way (no variable look-ups involved).
Reformulations during Optimization
==================================
Builtin ``zip`` for Python2
---------------------------
.. code:: python
def _zip(a, b, c): # Potentially more arguments.
# First assign, to preserve the order of execution, the arguments might be
# complex expressions with side effects.
tmp_arg1 = a
tmp_arg2 = b
tmp_arg3 = c
# could be more
...
# Creation of iterators goes first.
try:
tmp_iter_1 = iter(tmp_arg1)
except TypeError:
raise TypeError("zip argument #1 must support iteration")
try:
tmp_iter_2 = iter(tmp_arg2)
except TypeError:
raise TypeError("zip argument #2 must support iteration")
try:
tmp_iter_3 = iter(tmp_arg3)
except TypeError:
raise TypeError("zip argument #3 must support iteration")
# could be more
...
tmp_result = []
try:
while 1:
tmp_result.append(
(
next(tmp_iter_1),
next(tmp_iter_2),
next(tmp_iter_3),
# more arguments here ...
)
)
except StopIteration:
pass
return tmp_result
Builtin ``zip`` for Python3
^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. code:: python
for x, y, z in zip(a, b, c):
...
.. code:: python
def _zip_gen_object(a, b, c, ...):
...
# See Python2
...
# could be more
...
while 1:
yield (
next(tmp_iter_1),
next(tmp_iter_2),
next(tmp_iter_3),
...
)
except StopIteration:
break
for x, y, z in _zip_gen_object(a, b, c):
...
Builtin ``map`` for Python2
---------------------------
.. code:: python
def _map():
# TODO: Not done yet.
pass
Builtin ``min``
---------------
.. code:: python
# TODO: keyfunc (Python2/3), defaults (Python3)
def _min(a, b, c): # Potentially more arguments.
tmp_arg1 = a
tmp_arg2 = b
tmp_arg3 = c
# more arguments here ...
result = tmp_arg1
if keyfunc is None: # can be decided during re-formulation
tmp_key_result = keyfunc(result)
tmp_key_candidate = keyfunc(tmp_arg2)
if tmp_key_candidate < tmp_key_result:
result = tmp_arg2
tmp_key_result = tmp_key_candidate
tmp_key_candidate = keyfunc(tmp_arg3)
if tmp_key_candidate < tmp_key_result:
result = tmp_arg3
tmp_key_result = tmp_key_candidate
# more arguments here ...
else:
if tmp_arg2 < result:
result = tmp_arg2
if tmp_arg3 < result:
result = tmp_arg3
# more arguments here ...
return result
Builtin ``max``
---------------
See ``min`` just with ``>`` instead of ``<``.
Call to ``dir`` without arguments
---------------------------------
This expression is reformulated to ``locals().keys()`` for Python2, and
``list(locals.keys())`` for Python3.
Calls to functions with known signatures
----------------------------------------
As a necessary step for inlining function calls, we need to change calls
to variable references to function references.
.. code:: python
def f(arg1, arg2):
return some_op(arg1, arg2)
# ... other code
x = f(a, b + c)
In the optimization it is turned into
.. code:: python
# ... other code
x = lambda arg1, arg2: some_op(arg1, arg2)(a, b + c)
.. note::
The ``lambda`` stands here for a reference to the function, rather
than a variable reference, this is the normal forward propagation of
values, and does not imply duplicating or moving any code at all.
At this point, we still have not resolved the actual call arguments to
the variable names, still a Python level function is created, and
called, and arguments are parsed to a tuple, and from a tuple. For
simplicity sake, we have left out keyword arguments out of the equation
for now, but they are even more costly.
So now, what we want to do, is to re-formulate the call into what we
call an outline body, which is a inline function, and that does the
parameter parsing already and contains the function code too. In this
inlining, there still is a function, but it's technically not a Python
function anymore, just something that is an expression whose value is
determined by control flow and the function call.
.. code:: python
# ... other code
def _f():
tmp_arg1 = arg1
tmp_arg2 = b + c
return tmp_arg1 + tmp_arg2
x = _f()
With this, a function is considered inlined, because it becomes part of
the abstract execution, and the actual code is duplicated.
The point is, that matching the signature of the function to the actual
arguments given, is pretty straight forward in many cases, but there are
two forms of complications that can happen. One is default values,
because they need to assigned or not, and the other is keyword
arguments, because they allow to reorder arguments.
Let's consider an example with default values first.
.. code:: python
def f(arg1, arg2=some_default()):
return some_op(arg1, arg2)
# ... other code
x = f(a, b + c)
Since the point, at which defaults are taken, we must execute them at
that point and make them available.
.. code:: python
tmp_defaults = (some_default,) # that was f.__defaults__
# ... other code
def _f():
tmp_arg1 = arg1
tmp_arg2 = tmp_defaults[0]
return tmp_arg1 + tmp_arg2
x = _f()
Now, one where keyword arguments are ordered the other way.
.. code:: python
def f(arg1, arg2):
return some_op(arg1, arg2)
# ... other code
x = f(arg2=b + c, arg1=a) # "b+c" is evaluated before "a"
The solution is an extra level of temporary variables. We remember the
argument order by names and then assign parameters from it:
.. code:: python
# ... other code
def _f():
tmp_given_value1 = b + c
tmp_given_value2 = a
tmp_arg1 = tmp_given_value2
tmp_arg2 = tmp_given_value1
return tmp_arg1 + tmp_arg2
x = _f()
Obviously, optimization of Nuitka can decide, that e.g. should ``a`` or
``b+c`` not have side effects, to optimize these with standard variable
tracing away.
Nodes that serve special purposes
=================================
Try statements
--------------
In Python, there is ``try``/``except`` and ``try``/``finally``. In
Nuitka there is only a ``try``, which then has blocks to handle
exceptions, ``continue``, or ``break``, or ``return``. There is no
``else`` to this node type.
This is more low level and universal. Code for the different handlers
can be different. User provided ``finally`` blocks become copied into
the different handlers.
Releases
--------
When a function exits, the local variables are to be released. The same
applies to temporary variables used in re-formulations. These releases
cause a reference to the object to the released, but no value change.
They are typically the last use of the object in the function.
The are similar to ``del``, but make no value change. For shared
variables this effect is most visible.
Side Effects
------------
When an exception is bound to occur, and this can be determined at
compile time, Nuitka will not generate the code the leads to the
exception, but directly just raise it. But not in all cases, this is the
full thing.
Consider this code:
.. code:: python
f(a(), 1 / 0)
The second argument will create a ``ZeroDivisionError`` exception, but
before that ``a()`` must be executed, but the call to ``f`` will never
happen and no code is needed for that, but the name look-up must still
succeed. This then leads to code that is internally like this:
.. code:: python
f(a(), raise_ZeroDivisionError())
which is then modeled as:
.. code:: python
side_effect(a(), f, raise_ZeroDivisionError())
where we can consider ``side_effect`` to be a function that returns the
last expression. Of course, if this is not part of another expression,
but close to statement level, side effects, can be converted to multiple
statements simply.
Another use case, is that the value of an expression can be predicted,
but that the language still requires things to happen, consider this:
.. code:: python
a = len((f(), g()))
We can tell that ``a`` will be 2, but the call to ``f`` and ``g`` must
still be performed, so it becomes:
.. code:: python
a = side_effects(f(), g(), 2)
Modelling side effects explicitly has the advantage of recognizing them
easily and allowing to drop the call to the tuple building and checking
its length, only to release it.
Caught Exception Type/Value References
--------------------------------------
When catching an exception, these are not directly put to
``sys.exc_info()``, but remain as mere C variables. From there, they can
be accessed with these nodes, or if published then from the thread
state.
Hard Module Imports
-------------------
These are module look-ups that don't depend on any local variable for
the module to be looked up, but with hard-coded names. These may be the
result of optimization gaining such level of certainty.
Currently they are used to represent ``sys.stdout`` usage for ``print``
statements, but other usages will follow.
Locals Dict Update Statement
----------------------------
For the ``exec`` re-formulation, we apply an explicit sync back to
locals as an explicit node. It helps us to tell the affected local
variable traces that they might be affected. It represents the bit of
``exec`` in Python2, that treats ``None`` as the locals argument as an
indication to copy back.
Optimizing Attribute Lookups into Method Calls for Built-ins types
==================================================================
The attribute lookup node ``ExpressionAttributeLookup`` represents
looking up an attribute name, that is known to be a string. That's
already a bit more special, than say what ``ExpressionBuiltinGetattr``
does for ``getattr``, where it could be any object being looked up. From
the Python syntax however, these are what gets created, as it's not
allowed in any other way. So, this is where this starts.
Then, when we are creating an attribute node with a *fixed* name, we
dispatch it to generated node classes, e.g.
``ExpressionAttributeLookupFixedAppend``. This will be the same, except
that the attribute name is hardcoded.
There are generated, such that they can have code that is special for
``.append`` lookups. In their case, it makes sense to ask the source, if
they are a ``list`` object exactly. It doesn't make sense to do this
check for names that the ``list`` does not contain. So at that stage, we
are saving both a bit of memory and time.
Should this question succeed, i.e. the expression the attribute values
is looked up upon, is known to be a ``list`` exactly, we persist this
knowledge in the also generated nodes that represent ``list.append`` and
just that. It is called ``ExpressionAttributeLookupListAppend`` and only
represents the knowledge gained so far.
We do not consider if ``ExpressionAttributeLookupFixedAppend`` is
called, or not, passed as an argument, assigned somewhere, it doesn't
matter yet, but for ``ExpressionAttributeLookupListAppend`` we know a
hell of a lot more. We know its type, we know attributes for it, say
``__name__``, as it is a compile time constant, therefore much
optimization can follow for them, and code generation can specialize
them too (not yet done).
Should these nodes then, and say this happens later after some inlining
happens be seen as called, we can then turn them into method call nodes,
checking the arguments and such, this is then
``ExpressionListOperationAppend`` and at this point, will raising errors
with wrong argument counts.
And then we have this ``ExpressionListOperationAppend`` which will
influence the tracing of ``list`` contents, i.e. it will be able to tell
the ``list`` in question is no more empty after this ``append``, and it
will be able to at least predict the last element value, truth value of
the list, etc.
******************************
Plan to add "ctypes" support
******************************
Add interfacing to C code, so Nuitka can turn a ``ctypes`` binding into
an efficient binding as if it were written manually with Python C-API or
better.
Goals/Allowances to the task
============================
#. Goal: Must not directly use any pre-existing C/C++ language file
headers, only generate declarations in generated C code ourselves. We
would rather write or use tools that turn an existing a C header to
some ``ctypes`` declarations if it needs to be, but not mix and use
declarations from existing header code.
.. note::
The "cffi" interface maybe won't have the issue, but it's not
something we need to write or test the code for.
#. Allowance: May use ``ctypes`` module at compile time to ask things
about ``ctypes`` and its types.
#. Goal: Should make use of ``ctypes``, to e.g. not hard code in Nuitka
what ``ctypes.c_int()`` gives on the current platform, unless there
is a specific benefit.
#. Allowance: Not all ``ctypes`` usages must be supported immediately.
#. Goal: Try and be as general as possible.
For the compiler, ``ctypes`` support should be hidden behind a
generic interface of some sort. Supporting ``math`` module should be
the same thing.
Type Inference - The Discussion
===============================
Main initial goal is to forward value knowledge. When you have ``a =
b``, that means that a and b now "alias". And if you know the value of
``b`` you can assume to know the value of ``a``. This is called
"aliasing".
When assigning ``a`` to something new, that won't change ``b`` at all.
But when an attribute is set, a method called of it, that might impact
the actual value, referenced by both. We need to understand mutable vs.
immutable though, as some things are not affected by aliasing in any
way.
.. code:: python
a = 3
b = a
b += 4 # a is not changed
a = [3]
b = a
b += [4] # a is changed indeed
If we cannot tell, we must assume that ``a`` might be changed. It's
either ``b`` or what ``a`` was before. If the type is not mutable, we
can assume the aliasing to be broken up, and if it is, we can assume
both to be the same value still.
When that value is a compile time constant, we will want to push it
forward, and we do that with "(Constant) Value Propagation", which is
implemented already. We avoid too large constants, and we properly trace
value assignments, but not yet aliases.
In order to fully benefit from type knowledge, the new type system must
be able to be fully friends with existing built-in types, but for
classes to also work with it, it should not be tied to them. The
behavior of a type ``long``, ``str``, etc. ought to be implemented as
far as possible with the built-in ``long``, ``str`` at compiled time as
well.
.. note::
This "use the real thing" concept extends beyond builtin types, e.g.
``ctypes.c_int()`` should also be used, but we must be aware of
platform dependencies. The maximum size of ``ctypes.c_int`` values
would be an example of that. Of course that may not be possible for
everything.
This approach has well proven itself with built-in functions already,
where we use real built-ins where possible to make computations. We
have the problem though that built-ins may have problems to execute
everything with reasonable compile time cost.
Another example, consider the following code:
.. code:: python
len("a" * 1000000000000)
To predict this code, calculating it at compile time using constant
operations, while feasible, puts an unacceptable burden on the
compilation.
Esp. we wouldn't want to produce such a huge constant and stream it, the
C++ code would become too huge. So, we need to stop the ``*`` operator
from being used at compile time and cope with reduced knowledge, already
here:
.. code:: python
"a" * 10000000000000
Instead, we would probably say that for this expression:
- The result is a ``str`` or a C level ``PyStringObject *``.
- We know its length exactly, it's ``10000000000000``.
- Can predict every of its elements when sub-scripted, sliced, etc., if
need be, with a function we may create.
Similar is true for this horrible (in Python2) thing:
.. code:: python
range(10000000000000)
So it's a rather general problem, this time we know:
- The result is a ``list`` or C level ``PyListObject *``.
- We know its length exactly, ``10000000000000``.
- Can predict every of its elements when index, sliced, etc., if need
be, with a function.
Again, we wouldn't want to create the list. Therefore Nuitka avoids
executing these calculation, when they result in constants larger than a
threshold of e.g. 256 elements. This concept has to be also applied to
large integers and more CPU and memory traps.
Now lets look at a more complete use case:
.. code:: python
for x in range(10000000000000):
doSomething()
Looking at this example, one traditional way to look at it, would be to
turn ``range`` into ``xrange``, and to note that ``x`` is unused. That
would already perform better. But really better is to notice that
``range()`` generated values are not used at all, but only the length of
the expression matters.
And even if ``x`` were used, only the ability to predict the value from
a function would be interesting, so we would use that computation
function instead of having an iteration source. Being able to predict
from a function could mean to have Python code to do it, as well as C
code to do it. Then code for the loop can be generated without any
CPython library usage at all.
.. note::
Of course, it would only make sense where such calculations are
"O(1)" complexity, i.e. do not require recursion like "n!" does.
The other thing is that CPython appears to at - run time - take length
hints from objects for some operations, and there it would help too, to
track length of objects, and provide it, to outside code.
Back to the original example:
.. code:: python
len("a" * 1000000000000)
The theme here, is that when we can't compute all intermediate
expressions, and we sure can't do it in the general case. But we can
still, predict some of properties of an expression result, more or less.
Here we have ``len`` to look at an argument that we know the size of.
Great. We need to ask if there are any side effects, and if there are,
we need to maintain them of course. This is already done by existing
optimization if an operation generates an exception.
.. note::
The optimization of ``len`` has been implemented and works for all
kinds of container creation and ranges.
Applying this to "ctypes"
=========================
The *not so specific* problem to be solved to understand ``ctypes``
declarations is maybe as follows:
.. code:: python
import ctypes
This leads to Nuitka in its tree to have an assignment from a
``__import__`` expression to the variable ``ctypes``. It can be
predicted by default to be a module object, and even better, it can be
known as ``ctypes`` from standard library with more or less certainty.
See the section about "Importing".
So that part is "easy", and it's what will happen. During optimization,
when the module ``__import__`` expression is examined, it should say:
- ``ctypes`` is a module
- ``ctypes`` is from standard library (if it is, might not be true)
- ``ctypes`` then has code behind it, called ``ModuleFriend`` that
knows things about it attributes, that should be asked.
The later is the generic interface, and the optimization should connect
the two, of course via package and module full names. It will need a
``ModuleFriendRegistry``, from which it can be pulled. It would be nice
if we can avoid ``ctypes`` to be loaded into Nuitka unless necessary, so
these need to be more like a plug-in, loaded only if necessary, i.e. the
user code actually uses ``ctypes``.
Coming back to the original expression, it also contains an assignment
expression, because it re-formulated to be more like this:
.. code:: python
ctypes = __import__("ctypes")
The assigned to object, simply gets the type inferred propagated as part
of an SSA form. Ideally, we could be sure that nothing in the program
changes the variable, and therefore have only one version of that
variable.
For module variables, when the execution leaves the module to unknown
code, or unclear code, it might change the variable. Therefore, likely
we will often only assume that it could still be ``ctypes``, but also
something else.
Depending on how well we control module variable assignment, we can
decide this more of less quickly. With "compiled modules" types, the
expectation is that it's merely a quick C ``==`` comparison check. The
module friend should offer code to allow a check if it applies, for
uncertain cases.
Then when we come to uses of it:
.. code:: python
ctypes.c_int()
At this point, using SSA, we are more of less sure, that ``ctypes`` is
at that point the module, and that we know what it's ``c_int`` attribute
is, at compile time, and what it's call result is. We will use the
module friend to help with that. It will attach knowledge about the
result of that expression during the SSA collection process.
This is more like a value forward propagation than anything else. In
fact, constant propagation should only be the special case of it, and
one design goal of Nuitka was always to cover these two cases with the
same code.
Excursion to Functions
======================
In order to decide what this means to functions and their call
boundaries, if we propagate forward, how to handle this:
.. code:: python
def my_append(a, b):
a.append(b)
return a
We annotate that ``a`` is first a "unknown but defined parameter
object", then later on something that definitely has an ``append``
attribute, when returned, as otherwise an exception occurs.
The type of ``a`` changes to that after ``a.append`` look-up succeeds.
It might be many kinds of an object, but e.g. it could have a higher
probability of being a ``PyListObject``. And we would know it cannot be
a ``PyStringObject``, as that one has no ``append`` method, and would
have raised an exception therefore.
.. note::
If classes, i.e. other types in the program, have an ``append``
attribute, it should play a role too, there needs to be a way to
plug-in to this decisions.
.. note::
On the other hand, types without ``append`` attribute can be
eliminated.
Therefore, functions through SSA provide an automatic analysis on their
return state, or return value types, or a quick way to predict return
value properties, based on input value knowledge.
So this could work:
.. code:: python
b = my_append([], 3)
assert b == [3] # Could be decided now
Goal: The structure we use makes it easy to tell what ``my_append`` may
be. So, there should be a means to ask it about call results with given
type/value information. We need to be able to tell, if evaluating
``my_append`` makes sense with given parameters or not, if it does
impact the return value.
We should e.g. be able to make ``my_append`` tell, one or more of these:
- Returns the first parameter value as return value (unless it raises
an exception).
- The return value has the same type as ``a`` (unless it raises an
exception).
- The return value has an ``append`` attribute.
- The return value might be a ``list`` object.
- The return value may not be a ``str`` object.
- The function will raise if first argument has no ``append``
attribute.
The exactness of statements may vary. But some things may be more
interesting. If e.g. the aliasing of a parameter value to the return
value is known exactly, then information about it need to all be given
up, but some can survive.
It would be nice, if ``my_append`` had sufficient information, so we
could specialize with ``list`` and ``int`` from the parameters, and then
e.g. know at least some things that it does in that case. Such
specialization would have to be decided if it makes sense. In the
alternative, it could be done for each variant anyway, as there won't be
that many of them.
Doing this "forward" analysis appears to be best suited for functions
and therefore long term. We will try it that way.
Excursion to Loops
==================
.. code:: python
a = 1
while 1: # think loop: here
b = a + 1
a = b
if cond():
break
print(a)
The handling of loops (both ``for`` and ``while`` are re-formulated to
this kind of loops with ``break`` statements) has its own problem. The
loop start and may have an assumption from before it started, that ``a``
is constant, but that is only true for the first iteration. So, we can't
pass knowledge from outside loop forward directly into the for loop
body.
So the collection for loops needs to be two pass for loops. First, to
collect assignments, and merge these into the start state, before
entering the loop body. The need to make two passes is special to loops.
For a start, it is done like this. At loop entry, all pre-existing, but
written traces, are turned into loop merges. Knowledge is not completely
removed about everything assigned or changed in the loop, but then it's
not trusted anymore.
From that basis, the ``break`` exits are analysed, and merged, building
up the post loop state, and ``continue`` exits of the loop replacing the
unknown part of the loop entry state. The loop end is considered a
``continue`` for this purpose.
Excursion to Conditions
=======================
.. code:: python
if cond:
x = 1
else:
x = 2
b = x < 3
The above code contains a condition, and these have the problem, that
when exiting the conditional block, a merge must be done, of the ``x``
versions. It could be either one. The merge may trace the condition
under which a choice is taken. That way, we could decide pairs of traces
under the same condition.
These merges of SSA variable "versions", represent alternative values.
They pose difficulties, and might have to be reduced to commonality. In
the above example, the ``<`` operator will have to check for each
version, and then to decide that both indeed give the same result.
The trace collection tracks variable changes in conditional branches,
and then merges the existing state at conditional statement exits.
.. note::
A branch is considered "exiting" if it is not abortive. Should it end
in a ``raise``, ``break``, ``continue``, or ``return``, there is no
need to merge that branch, as execution of that branch is terminated.
Should both branches be abortive, that makes things really simple, as
there is no need to even continue.
Should only one branch exist, but be abortive, then no merge is
needed, and the collection can assume after the conditional
statement, that the branch was not taken, and continue.
When exiting both the branches, these branches must both be merged, with
their new information.
In the above case:
- The "yes" branch knows variable ``x`` is an ``int`` of constant value
``1``
- The "no" branch knows variable ``x`` is an ``int`` of constant value
``2``
That might be collapsed to:
- The variable ``x`` is an integer of value in ``(1,2)``
Given this, we then should be able to pre-compute the value of this:
.. code:: python
b = x < 3
The comparison operator can therefore decide and tell:
- The variable ``b`` is a boolean of constant value ``True``.
Were it unable to decide, it would still be able to say:
- The variable ``b`` is a boolean.
For conditional statements optimization, it's also noteworthy, that the
condition is known to pass or not pass the truth check, inside branches,
and in the case of non-exiting single branches, after the statement it's
not true.
We may want to take advantage of it. Consider e.g.
.. code:: python
if type(a) is list:
a.append(x)
else:
a += (x,)
In this case, the knowledge that ``a`` is a list, could be used to
generate better code and with the definite knowledge that ``a`` is of
type list. With that knowledge the ``append`` attribute call will become
the ``list`` built-in type operation.
Excursion to ``return`` statements
==================================
The ``return`` statement (like ``break``, ``continue``, ``raise``) is
"aborting" to control flow. It is always the last statement of inspected
block. When there statements to follow it, optimization will remove it
as "dead code".
If all branches of a conditional statement are "aborting", the statement
is decided "aborting" too. If a loop doesn't abort with a break, it
should be considered "aborting" too.
Excursion to ``yield`` expressions
==================================
The ``yield`` expression can be treated like a normal function call, and
as such invalidates some known constraints just as much as they do. It
executes outside code for an unknown amount of time, and then returns,
with little about the outside world known anymore, if it's accessible
from there.
Mixed Types
===========
Consider the following inside a function or module:
.. code:: python
if cond is not None:
a = [x for x in something() if cond(x)]
else:
a = ()
A programmer will often not make a difference between ``list`` and
``tuple``. In fact, using a ``tuple`` is a good way to express that
something won't be changed later, as these are mutable.
.. note::
Better programming style, would be to use this:
.. code:: python
if cond is not None:
a = tuple(x for x in something() if cond(x))
else:
a = ()
People don't do it, because they dislike the performance hit
encountered by the generator expression being used to initialize the
tuple. But it would be more consistent, and so Nuitka is using it,
and of course one day Nuitka ought to be able to make no difference
in performance for it.
To Nuitka though this means, that if ``cond`` is not predictable, after
the conditional statement we may either have a ``tuple`` or a ``list``
type object in ``a``. In order to represent that without resorting to "I
know nothing about it", we need a kind of ``min``/``max`` operating
mechanism that is capable of say what is common with multiple
alternative values.
.. note::
At this time, we don't really have that mechanism to find the
commonality between values.
Back to "ctypes"
================
.. code:: python
v = ctypes.c_int()
Coming back to this example, we needed to propagate ``ctypes``, then we
can propagate "something" from ``ctypes.int`` and then known what this
gives with a call and no arguments, so the walk of the nodes, and
diverse operations should be addressed by a module friend.
In case a module friend doesn't know what to do, it needs to say so by
default. This should be enforced by a base class and give a warning or
note.
Now to the interface
====================
The following is the intended interface:
- Iteration with node methods ``computeStatement`` and
``computeExpression``.
These traverse modules and functions (i.e. scopes) and visit
everything in the order that Python executes it. The visiting object
is ``TraceCollection`` and pass forward. Some node types, e.g.
``StatementConditional`` new create branch trace collections and
handle the SSA merging at exit.
- Replacing nodes during the visit.
Both ``computeStatement`` and ``computeExpression`` are tasked to
return potential replacements of themselves, together with "tags"
(meaningless now), and a "message", used for verbose tracing.
The replacement node of ``+`` operator, may e.g. be the pre-computed
constant result, wrapped in side effects of the node, or the
expression raised, again wrapped in side effects.
- Assignments and references affect SSA.
The SSA tree is initialized every time a scope is visited. Then
during traversal, traces are built up. Every assignment and merge
starts a new trace for that matter. References to a given variable
version are traced that way.
- Value escapes are traced too.
When an operation hands over a value to outside code, it indicates so
to the trace collection. This is for it to know, when e.g. a constant
value, might be mutated meanwhile.
- Nodes can be queried about their properties.
There is a type shape and a value shape that each node can be asked
about. The type shape offers methods that allow to check if certain
operations are at all supported or not. These can always return
``True`` (yes), ``False`` (no), and ``None`` (cannot decide). In the
case of the later, optimizations may not be able do much about it.
Lets call these values "tri-state".
There is also the value shape of a node. This can go deeper, and be
more specific to a given node.
The default implementation will be very pessimistic. Specific node
types and shapes may then declare, that they e.g. have no side
effects, will not raise for certain operations, have a known truth
value, have a known iteration length, can predict their iteration
values, etc.
- Nodes are linked to certain states.
During the collect, a variable reference, is linked to a certain
trace state, and that can be used by parent operations.
.. code:: python
a = 1
b = a + a
In this example, the references to ``a``, can look-up the ``1`` in
the trace, and base value shape response to ``+`` on it. For compile
time evaluation, it may also ask ``isCompileTimeConstant()`` and if
both nodes will respond ``True``, then "getCompileTimeConstant()"
will return ``1``, which will be be used in computation.
Then ``extractSideEffects()`` for the ``a`` reference will return
``()`` and therefore, the result ``2`` will not be wrapped.
An alternative approach would be ``hasTypeSlotAdd()`` on the both
nodes, and they both do, to see if the selection mechanism used by
CPython can be used to find which types ``+`` should be used.
- Class for module import expression ``ExpressionImportModule``.
This one just knows that something is imported, but not how or what
it is assigned to. It will be able in a recursive compile, to provide
the module as an assignment source, or the module variables or
submodules as an attribute source when referenced from a variable
trace or in an expression.
- Base class for module friend ``ModuleFriendBase``.
This is intended to provide something to overload, which e.g. can
handle ``math`` in a better way.
- Module ``ModuleFriendRegistry``
Provides a register function with ``name`` and instances of
``ValueFriendModuleBase`` to be registered. Recursed to modules
should integrate with that too. The registry could well be done with
a metaclass approach.
- The module friends should each live in a module of their own.
With a naming policy to be determined. These modules should add
themselves via above mechanism to ``ModuleFriendRegistry`` and all
shall be imported and register. Importing of e.g. ``ctypes`` should
be delayed to when the friend is actually used. A meta class should
aid this task.
The delay will avoid unnecessary blot of the compiler at run time, if
no such module is used. For "qt" and other complex stuff, this will
be a must.
- The walk should initially be single pass, and not maintain history.
Instead optimization that needs to look at multiple things, e.g.
"unused assignment", will look at the whole SSA collection
afterwards.
Discussing with examples
========================
The following examples:
.. code:: python
# Assignment, the source decides the type of the assigned expression
a = b
# Operator "attribute look-up", the looked up expression "ctypes" decides
# via its trace.
ctypes.c_int
# Call operator, the called expressions decides with help of arguments,
# which have been walked, before the call itself.
called_expression_of_any_complexity()
# import gives a module any case, and the "ModuleRegistry" may say more.
import ctypes
# From import need not give module, "x" decides what it is.
from x import y
# Operations are decided by arguments, and CPython operator rules between
# argument states.
a + b
The optimization is mostly performed by walking of the tree and
performing trace collection. When it encounters assignments and
references to them, it considers current state of traces and uses it for
``computeExpression``.
.. note::
Assignments to attributes, indexes, slices, etc. will also need to
follow the flow of ``append``, so it cannot escape attention that a
list may be modified. Usages of ``append`` that we cannot be sure
about, must be traced to exist, and disallow the list to be
considered known value again.
Code Generation Impact
======================
Right now, code generation assumes that everything is a ``PyObject *``,
i.e. a Python object, and does not take knowledge of ``int`` or other
types into consideration at all, and it should remain like that for some
time to come.
Instead, ``ctypes`` value friend will be asked give ``Identifiers``,
like other codes do too. And these need to be able to convert themselves
to objects to work with the other things.
But Code Generation should no longer require that operations must be
performed on that level. Imagine e.g. the following calls:
.. code:: python
c_call(other_c_call())
Value returned by "other_c_call()" of say ``c_int`` type, should be
possible to be fed directly into another call. That should be easy by
having a ``asIntC()`` in the identifier classes, which the ``ctypes``
Identifiers handle without conversions.
Code Generation should one day also become able to tell that all uses of
a variable have only ``c_int`` value, and use ``int`` instead of
``PyObjectLocalVariable`` more or less directly. We could consider
``PyIntLocalVariable`` of similar complexity as ``int`` after the C++
compiler performed its in-lining.
Such decisions would be prepared by finalization, which then would track
the history of values throughout a function or part of it.
Initial Implementation
======================
The basic interface will be added to *all* expressions and a node may
override it, potentially using trace collection state, as attached
during ``computeExpression``.
Goal 1 (Reached)
----------------
Initially most things will only be able to give up on about anything.
And it will be little more than a tool to do simple look-ups in a
general form. It will then be the first goal to turn the following code
into better performing one:
.. code:: python
a = 3
b = 7
c = a / b
print(c)
to:
.. code:: python
a = 3
b = 7
c = 3 / 7
print(c)
and then:
.. code:: python
a = 3
b = 7
c = 0
print(c)
and then:
.. code:: python
a = 3
b = 7
c = 0
print(0)
This depends on SSA form to be able to tell us the values of ``a``,
``b``, and ``c`` to be written to by constants, which can be forward
propagated at no cost.
Goal 2 (Reached)
----------------
The assignments to ``a``, ``b``, and ``c`` shall all become prey to
"unused" assignment analysis in the next step. They are all only
assigned to, and the assignment source has no effect, so they can be
simply dropped.
.. code:: python
print(0)
In the SSA form, these are then assignments without references. These
assignments, can be removed if the assignment source has no side effect.
Or at least they could be made "anonymous", i.e. use a temporary
variable instead of the named one. That would have to take into account
though, that the old version still needs a release.
The most general form would first merely remove assignments that have no
impact, and leave the value as a side effect, so we arrive at this
first:
.. code:: python
3
7
0
print(0)
When applying the removal of expression only statements without effect,
this gives us:
.. code:: python
print(0)
which is the perfect result. Doing it in one step would only be an
optimization at the cost of generalization.
In order to be able to manipulate nodes related to a variable trace, we
need to attach the nodes that did it. Consider this:
.. code:: python
if cond():
x = 1
elif other():
x = 3
# Not using "x".
print(0)
In the above case, the merge of the value traces, should say that ``x``
may be undefined, or one of ``1`` or ``3``, but since ``x`` is not used,
apply the "dead value" trick to each branch.
The removal of the "merge" of the 3 ``x`` versions, should exhibit that
the other versions are also only assigned to, and can be removed. These
merges of course appear as usages of the ``x`` versions.
Goal 3
------
Then third goal is to understand all of this:
.. code:: python
def f():
a = []
print(a)
for i in range(1000):
print(a)
a.append(i)
return len(a)
.. note::
There are many operations in this, and all of them should be properly
handled, or at least ignored in safe way.
The first goal code gave us that the ``list`` has an annotation from the
assignment of ``[]`` and that it will be copied to ``a`` until the for
loop in encountered. Then it must be removed, because the ``for`` loop
somehow says so.
The ``a`` may change its value, due to the unknown attribute look-up of
it already, not even the call. The for loop must be able to say "may
change value" due to that, of course also due to the call of that
attribute too.
The code should therefore become equivalent to:
.. code:: python
def f():
a = []
print([])
for i in range(1000):
print(a)
a.append(i)
return len(a)
But no other changes must occur, especially not to the ``return``
statement, it must not assume ``a`` to be constant "[]" but an unknown
``a`` instead.
With that, we would handle this code correctly and have some form
constant value propagation in place, handle loops at least correctly,
and while it is not much, it is important demonstration of the concept.
Goal 4
------
The fourth goal is to understand the following:
.. code:: python
def f(cond):
y = 3
if cond:
x = 1
else:
x = 2
return x < y
In this we have a branch, and we will be required to keep track of both
the branches separately, and then to merge with the original knowledge.
After the conditional statement we will know that "x" is an "int" with
possible values in ``(1,2)``, which can be used to predict that the
return value is always ``True``.
The fourth goal will therefore be that the "ValueFriendConstantList"
knows that append changes ``a`` value, but it remains a list, and that
the size increases by one. It should provide an other value friend
"ValueFriendList" for "a" due to that.
In order to do that, such code must be considered:
.. code:: python
a = []
a.append(1)
a.append(2)
print(len(a))
It will be good, if ``len`` still knows that ``a`` is a list object, but
not the constant list anymore.
From here, work should be done to demonstrate the correctness of it with
the basic tests applied to discover undetected issues.
Fifth and optional goal: Extra bonus points for being able to track and
predict ``append`` to update the constant list in a known way. Using
``list.append`` that should be done and lead to a constant result of
``len`` being used.
The sixth and challenging goal will be to make the code generation be
impacted by the value friends types. It should have a knowledge that
``PyList_Append`` does the job of append and use ``PyList_Size`` for
``len``. The "ValueFriends" should aid the code generation too.
Last and right now optional goal will be to make ``range`` have a value
friend, that can interact with iteration of the for loop, and ``append``
of the ``list`` value friend, so it knows it's possible to iterate 5000
times, and that "a" has then after the "loop" this size, so ``len(a)``
could be predicted. For during the loop, about a the range of its length
should be known to be less than 5000. That would make the code of goal 2
completely analyzed at compile time.
Limitations for now
===================
- Aim only for limited examples. For ``ctypes`` that means to compile
time evaluate:
.. code:: python
print(ctypes.c_int(17) + ctypes.c_long(19))
Later then call to "libc" or something else universally available,
e.g. "strlen()" or "strcmp()" from full blown declarations of the
callable.
- We won't have the ability to test that optimization are actually
performed, we will check the generated code by hand.
With time, we will add XML based checks with "xpath" queries,
expressed as hints, but that is some work that will be based on this
work here. The "hints" fits into the "ValueFriends" concept nicely or
so the hope is.
- No inter-function optimization functions yet
Of course, once in place, it will make the ``ctypes`` annotation even
more usable. Using ``ctypes`` objects inside functions, while
creating them on the module level, is therefore not immediately going
to work.
- No loops yet
Loops break value propagation. For the ``ctypes`` use case, this
won't be much of a difficulty. Due to the strangeness of the task, it
should be tackled later on at a higher priority.
- Not too much.
Try and get simple things to work now. We shall see, what kinds of
constraints really make the most sense. Understanding ``list``
subscript/slice values e.g. is not strictly useful for much code and
should not block us.
.. note::
This design is not likely to be the final one.
***********************************
How to make Features Experimental
***********************************
Every experimental feature needs a name. We have a rule to pick a name
with lower case and ``_`` as separators. An example of with would be the
name ``jinja_generated_add`` that has been used in the past.
Command Line
============
Experimental features are enabled with the command line argument
.. code:: bash
nuitka --experimental=jinja_generated_add ...
In C code
=========
In Scons, all experimental features automatically are converted into C
defines, and can be used like this:
.. code:: C
#ifdef _NUITKA_EXPERIMENTAL_JINJA_GENERATED_ADD
#include "HelpersOperationGeneratedBinaryAdd.c"
#else
#include "HelpersOperationBinaryAdd.c"
#endif
The C pre-processor is the only thing that makes an experimental feature
usable.
In Python
=========
You can query experimental features using ``Options.isExperimental()``
with e.g. code like this:
.. code:: python
if Options.isExperimental("use_feature"):
experimental_code()
else:
standard_code()
When to use it
==============
Often we need to keep feature in parallel because they are not finished,
or need to be tested after merge and should not break. Then we can do
code changes that will not make a difference except when the
experimental flag is given on the command line to Nuitka.
The testing of Nuitka is very heavy weight when e.g. all Python code is
compiled, and very often, it is interesting to compare behavior with and
without a change.
When to remove it
=================
When a feature becomes default, we might choose to keep the old variant
around, but normally we do not. Then we remove the ``if`` and ``#if``
checks and drop the old code.
At this time, large scale testing will have demonstrated the viability
of the code.
*******************************
Adding dependencies to Nuitka
*******************************
First of all, there is an important distinction to make, run time or
development time. The first kind of dependency is used when Nuitka is
executing.
Adding a Run Time Dependency
============================
This is the kind of dependency that is the most scrutinized. As we want
Nuitka to run on latest greatest Python as well as relatively old ones,
we have to be very careful with these ones.
There is also a distinction of optional dependencies. Right now e.g. the
``lxml`` package is relatively optional, and Nuitka can work without it
being installed, because e.g. on some platforms it will not be easy to
do so. That bar has lifted somewhat, but it means e.g. that XML based
optimization tests are not run with all Python versions.
The list of run time dependencies is in ``requirements.txt`` and it is
for those the case, that they are not really required to be installed by
the user, consider this snippet:
.. code:: python
# Folders to use for cache files.
appdirs
# Scons is the backend building tool to turn C files to binaries.
scons
For both these dependencies, there is either an inline copy (Scons) that
we handle to use in case, if Scons is not available (in fact we have a
version that works with Python 2.6 and 2.7 still), and also the same for
appdirs and every dependency.
But since inline copies are against the rules on some platforms that
still do not contain the package, we often even have our own wrapper
which provides a minimal fallback or exposes a sane interface for the
subset of functionality that we use.
.. note::
Therefore, please if you consider adding one of these, get in touch
with ``@Nuitka-pushers`` first and get a green light.
Adding a Development Dependency
===============================
A typical example of a development dependency is ``black`` which is used
by our autoformat tool, and then in turn by the git pre-commit hook. It
is used to format source code, and doesn't have a role at run time of
the actual compiler code of Nuitka.
Much less strict rules apply to these in comparison to runtime
dependencies. Generally please take care that the tool must be well
maintained an available on newer Pythons. Then we can use it, no problem
normally. But if it's really big, say all of SciPy, we might want to
justify it a bit better.
The list of development dependencies is in ``requirements-devel.txt``
and it is for example like this:
.. code:: python
# Autoformat needs this
rstfmt == 0.0.10 ; python_version >= '3.7'
We always add the version, so that when tests run on as old versions as
Python 2.6, the installation would fail with that version, so we need to
make a version requirement. Sometimes we use older versions for Python2
than for Python3, ``Jinaj2`` being a notable candidate, but generally we
ought to avoid that. For many tools only being available for currently
3.7 or higher is good enough, esp. if they are run as development tools,
like ``autoformat-nuitka-source`` is.
**********
Idea Bin
**********
This an area where to drop random ideas on our minds, to later sort it
out, and out it into action, which could be code changes, plan changes,
issues created, etc.
- Make "SELECT_METACLASS" meta class selection transparent.
Looking at the "SELECT_METACLASS" it should become an anonymous
helper function. In that way, the optimization process can remove
choices at compile time, and e.g. in-line the effect of a meta class,
if it is known.
This of course makes most sense, if we have the optimizations in
place that will allow this to actually happen.
- Keeping track of iterations
The trace collection trace should become the place, where variables
or values track their use state. The iterator should keep track of
the "next()" calls made to it, so it can tell which value to given in
that case.
That would solve the "iteration of constants" as a side effect and it
would allow to tell that they can be removed.
That would mean to go back in the tree and modify it long after.
.. code:: python
a = iter((2, 3))
b = next(a)
c = next(a)
del a
It would be sweet if we could recognize that as:
.. code:: python
a = iter((2, 3))
b = side_effect(next(a), 2)
c = side_effect(next(a), 3)
del a
That trivially becomes:
.. code:: python
a = iter((2, 3))
next(a)
b = 2
next(a)
c = 3
del a
When the ``del a`` is examined at the end of scope, or due to another
assignment to the same variable, ending the trace, we would have to
consider of the ``next`` uses, and retrofit the information that they
had no effect.
.. code:: python
a = iter((2, 3))
b = 2
b = 3
del a
- Aliasing
Each time an assignment is made, an alias is created. A value may
have different names.
.. code:: python
a = iter(range(9))
b = a
c = next(b)
d = next(a)
If we fail to detect the aliasing nature, we will calculate ``d``
wrongly. We may incref and decref values to trace it.
Aliasing is automatically traced already in SSA form. The ``b`` is
assigned to version of ``a``. So, that should allow to replace it
with this:
.. code:: python
a = iter(range(9))
c = next(a)
d = next(a)
Which then will be properly handled.
- Tail recursion optimization.
Functions that return the results of calls, can be optimized. The
Stackless Python does it already.
- Integrate with "upx" compression.
Calling "upx" on the created binaries, would be easy.
- In-lining constant "exec" and "eval".
It should be possible to re-formulate at least cases without "locals"
or "globals" given.
.. code:: python
def f():
a = 1
b = 2
exec("""a+=b;c=1""")
return a, c
Should become this here:
.. code:: python
def f():
a = 1
b = 2
a += b #
c = 1 # MaybeLocalVariables for everything except known local ones.
return a, c
If this holds up, inlining ``exec`` should be relatively easy.
- Original and overloaded built-ins
This is about making things visible in the node tree. In Nuitka
things that are not visible in the node tree tend to be wrong. We
already pushed around information to the node tree a lot.
Later versions, Nuitka will become able to determine it has to be the
original built-in at compile time, then a condition that checks will
be optimized away, together with the slow path. Or the other path, if
it won't be. Then it will be optimized away, or if doubt exists, it
will be correct. That is the goal.
Right now, the change would mean to effectively disable all built-in
call optimization, which is why we don't immediately do it.
Making the compatible version, will also require a full listing of
all built-ins, which is typing work merely, but not needed now. And a
way to stop built-in optimization from optimizing built-in calls that
it used in a wrap. Probably just some flag to indicate it when it
visits it to skip it. That's for later.
But should we have that both, I figure, we could not raise a
``RuntimeError`` error, but just do the correct thing, in all cases.
An earlier step may raise ``RuntimeError`` error, when built-in
module values are written to, that we don't support.
******************
Prongs of Action
******************
In this chapter, we keep track of prongs of action currently ongoing.
This can get detailed and shows things we strive for.
Builtin optimization
====================
Definitely want to get built-in names under full control, so that
variable references to module variables do not have a twofold role.
Currently they reference the module variable and also the potential
built-in as a fallback.
In terms of generated code size and complexity for modules with many
variables and uses of them that is horrible. But ``some_var`` (normally)
cannot be a built-in and therefore needs no code to check for that each
time.
This is also critical to getting to whole program optimization. Being
certain what is what there on module level, will enable more definitely
knowledge about data flows and module interfaces.
Class Creation Overhead Reduction
=================================
This is more of a meta goal. Some work for the metaclass has already
been done, but that is Python2 only currently. Being able to to decide
built-ins and to distinguish between global only variables, and
built-ins more clearly will help this a lot.
In the end, empty classes should be able to be statically converted to
calls to ``type`` with static dictionaries. The inlining of class
creation function is also needed for this, but on Python3 cannot happen
yet.
Memory Usage at Compile Time
============================
We will need to store more and more information in the future. Getting
the tree to be tight shaped is therefore an effort, where we will be
spending time too.
The mix-ins prevent slots usage, so lets try and get rid of those. The
"children having" should become more simple and faster code. I am even
thinking of even generating code in the meta class, so it's both optimal
and doesn't need that mix-in any more. This is going to be ugly then.
Coverage Testing
================
And then there is coverage, it should be taken and merged from all
Python versions and OSes, but I never managed to merge between Windows
and Linux for unknown reasons.
Python3 Performance
===================
The Python3 lock for thread state is making it slower by a lot. I have
only experimental code that just ignores the lock, but it likely only
works on Linux, and I wonder why there is that lock in the first place.
Ignoring the locks cannot be good. But what updates that thread state
pointer ever without a thread change, and is this what ABI flags are
about in this context, are there some that allow us to ignore the locks.
An important bit would be to use a thread state once acquired for as
much as possible, currently exception helpers do not accept it as an
argument, but that ought to become an option, that way saving and
restoring an exception will be much faster, not to mention checking and
dropping non interesting, or rewriting exceptions.
Caching of Python level compilation
===================================
While the C compilation result is already cached with `ccache` and
friends now, we need to also cover our bases and save the resulting node
tree of potential expensive optimization on the module level.
*************************
Updates for this Manual
*************************
This document is written in REST. That is an ASCII format which is
readable to human, but easily used to generate PDF or HTML documents.
You will find the current source under:
https://github.com/Nuitka/Nuitka/blob/develop/Developer_Manual.rst
And the current PDF under: https://nuitka.net/doc/Developer_Manual.pdf
================================================
FILE: LICENSE.txt
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes
gitextract_8msbk7ao/
├── .editorconfig
├── .gitattributes
├── .githooks/
│ └── pre-commit
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ └── testing.yml
├── .gitignore
├── .gitmodules
├── .sourcery.yaml
├── .vscode/
│ ├── c_cpp_properties.json
│ ├── extensions.json
│ └── settings.json
├── CODE_OF_CONDUCT.rst
├── CONTRIBUTING.md
├── Changelog.rst
├── Developer_Manual.rst
├── LICENSE.txt
├── MANIFEST.in
├── README.rst
├── SECURITY.md
├── Standard-Plugins-Documentation.rst
├── UserPlugin-Creation.rst
├── Using-Plugin-Options.rst
├── bin/
│ ├── autoformat-nuitka-source
│ ├── check-nuitka-with-codespell
│ ├── check-nuitka-with-pylint
│ ├── check-nuitka-with-restlint
│ ├── check-nuitka-with-yamllint
│ ├── check-reference-counts
│ ├── compare_with_cpython
│ ├── compare_with_xml
│ ├── find_sxs_modules
│ ├── generate-specialized-c-code
│ ├── generate-specialized-python-code
│ ├── measure-construct-performance
│ ├── nuitka
│ ├── nuitka-run
│ ├── nuitka-watch
│ ├── nuitka3
│ ├── nuitka3-run
│ └── run-inside-nuitka-container
├── debian/
│ ├── README.source
│ ├── changelog
│ ├── compat
│ ├── control
│ ├── copyright
│ ├── nuitka.docs
│ ├── nuitka.manpages
│ ├── pbuilder-hookdir/
│ │ └── B92test-installed-nuitka
│ ├── rules
│ ├── source/
│ │ ├── format
│ │ └── lintian-overrides
│ ├── upstream-signing-key.pgp
│ └── watch
├── doc/
│ ├── Doxyfile.template
│ ├── custom.css
│ ├── nuitka-man-include.txt
│ ├── nuitka-run.1
│ ├── nuitka.1
│ └── uml/
│ ├── standalone-overview.plantuml
│ └── use-cases.plantuml
├── lib/
│ └── hints.py
├── misc/
│ ├── codespell-ignore.txt
│ ├── create-pbuilder-image.py
│ ├── dump-config-options.py
│ ├── install-git-hooks.py
│ ├── make-apidoc.py
│ ├── make-coverage-rendering.py
│ ├── make-deb-mentors-release.py
│ ├── make-deb-release.py
│ ├── make-pypi-upload.py
│ ├── make-release.py
│ ├── make-upload.py
│ ├── make-version-bump.py
│ ├── nuitka-package-config-schema.json
│ ├── nuitka-run.bat
│ ├── nuitka.bat
│ ├── run-valgrind.py
│ └── update-doc.py
├── nuitka/
│ ├── Builtins.py
│ ├── BytecodeCaching.py
│ ├── Bytecodes.py
│ ├── CacheCleanup.py
│ ├── Constants.py
│ ├── Errors.py
│ ├── HardImportRegistry.py
│ ├── MainControl.py
│ ├── ModuleRegistry.py
│ ├── OptionParsing.py
│ ├── Options.py
│ ├── OutputDirectories.py
│ ├── PostProcessing.py
│ ├── Progress.py
│ ├── PythonFlavors.py
│ ├── PythonOperators.py
│ ├── PythonVersions.py
│ ├── Serialization.py
│ ├── SourceCodeReferences.py
│ ├── Tracing.py
│ ├── TreeXML.py
│ ├── Variables.py
│ ├── Version.py
│ ├── __init__.py
│ ├── __main__.py
│ ├── __past__.py
│ ├── build/
│ │ ├── Backend.scons
│ │ ├── CCompilerVersion.scons
│ │ ├── DataComposerInterface.py
│ │ ├── Onefile.scons
│ │ ├── SconsCaching.py
│ │ ├── SconsCompilerSettings.py
│ │ ├── SconsHacks.py
│ │ ├── SconsInterface.py
│ │ ├── SconsProgress.py
│ │ ├── SconsSpawn.py
│ │ ├── SconsUtils.py
│ │ ├── __init__.py
│ │ ├── include/
│ │ │ └── nuitka/
│ │ │ ├── allocator.h
│ │ │ ├── builtins.h
│ │ │ ├── calling.h
│ │ │ ├── checkers.h
│ │ │ ├── checksum_tools.h
│ │ │ ├── compiled_asyncgen.h
│ │ │ ├── compiled_cell.h
│ │ │ ├── compiled_coroutine.h
│ │ │ ├── compiled_frame.h
│ │ │ ├── compiled_function.h
│ │ │ ├── compiled_generator.h
│ │ │ ├── compiled_method.h
│ │ │ ├── constants.h
│ │ │ ├── constants_blob.h
│ │ │ ├── environment_variables.h
│ │ │ ├── environment_variables_system.h
│ │ │ ├── exception_groups.h
│ │ │ ├── exceptions.h
│ │ │ ├── filesystem_paths.h
│ │ │ ├── freelists.h
│ │ │ ├── hedley.h
│ │ │ ├── helper/
│ │ │ │ ├── attributes.h
│ │ │ │ ├── boolean.h
│ │ │ │ ├── bytearrays.h
│ │ │ │ ├── bytes.h
│ │ │ │ ├── calling_generated.h
│ │ │ │ ├── comparisons_eq.h
│ │ │ │ ├── comparisons_ge.h
│ │ │ │ ├── comparisons_gt.h
│ │ │ │ ├── comparisons_le.h
│ │ │ │ ├── comparisons_lt.h
│ │ │ │ ├── comparisons_ne.h
│ │ │ │ ├── complex.h
│ │ │ │ ├── dictionaries.h
│ │ │ │ ├── floats.h
│ │ │ │ ├── import_hard.h
│ │ │ │ ├── indexes.h
│ │ │ │ ├── ints.h
│ │ │ │ ├── iterators.h
│ │ │ │ ├── lists.h
│ │ │ │ ├── lists_generated.h
│ │ │ │ ├── mappings.h
│ │ │ │ ├── operations.h
│ │ │ │ ├── operations_binary_add.h
│ │ │ │ ├── operations_binary_bitand.h
│ │ │ │ ├── operations_binary_bitor.h
│ │ │ │ ├── operations_binary_bitxor.h
│ │ │ │ ├── operations_binary_divmod.h
│ │ │ │ ├── operations_binary_floordiv.h
│ │ │ │ ├── operations_binary_lshift.h
│ │ │ │ ├── operations_binary_matmult.h
│ │ │ │ ├── operations_binary_mod.h
│ │ │ │ ├── operations_binary_mult.h
│ │ │ │ ├── operations_binary_olddiv.h
│ │ │ │ ├── operations_binary_pow.h
│ │ │ │ ├── operations_binary_rshift.h
│ │ │ │ ├── operations_binary_sub.h
│ │ │ │ ├── operations_binary_truediv.h
│ │ │ │ ├── operations_builtin_types.h
│ │ │ │ ├── operations_inplace_add.h
│ │ │ │ ├── operations_inplace_bitand.h
│ │ │ │ ├── operations_inplace_bitor.h
│ │ │ │ ├── operations_inplace_bitxor.h
│ │ │ │ ├── operations_inplace_floordiv.h
│ │ │ │ ├── operations_inplace_lshift.h
│ │ │ │ ├── operations_inplace_matmult.h
│ │ │ │ ├── operations_inplace_mod.h
│ │ │ │ ├── operations_inplace_mult.h
│ │ │ │ ├── operations_inplace_olddiv.h
│ │ │ │ ├── operations_inplace_pow.h
│ │ │ │ ├── operations_inplace_rshift.h
│ │ │ │ ├── operations_inplace_sub.h
│ │ │ │ ├── operations_inplace_truediv.h
│ │ │ │ ├── raising.h
│ │ │ │ ├── rangeobjects.h
│ │ │ │ ├── richcomparisons.h
│ │ │ │ ├── sequences.h
│ │ │ │ ├── sets.h
│ │ │ │ ├── slices.h
│ │ │ │ ├── strings.h
│ │ │ │ ├── subscripts.h
│ │ │ │ └── tuples.h
│ │ │ ├── helpers.h
│ │ │ ├── importing.h
│ │ │ ├── incbin.h
│ │ │ ├── jit_sources.h
│ │ │ ├── prelude.h
│ │ │ ├── printing.h
│ │ │ ├── python_pgo.h
│ │ │ ├── safe_string_ops.h
│ │ │ ├── threading.h
│ │ │ ├── tracing.h
│ │ │ └── unfreezing.h
│ │ ├── inline_copy/
│ │ │ ├── appdirs/
│ │ │ │ ├── LICENSE.txt
│ │ │ │ └── appdirs.py
│ │ │ ├── atomicwrites/
│ │ │ │ ├── LICENSE
│ │ │ │ └── atomicwrites.py
│ │ │ ├── bin/
│ │ │ │ └── scons.py
│ │ │ ├── clcache/
│ │ │ │ └── clcache/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── __init__.py
│ │ │ │ └── caching.py
│ │ │ ├── colorama/
│ │ │ │ ├── LICENSE.txt
│ │ │ │ └── colorama/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── ansi.py
│ │ │ │ ├── ansitowin32.py
│ │ │ │ ├── initialise.py
│ │ │ │ ├── win32.py
│ │ │ │ └── winterm.py
│ │ │ ├── glob2/
│ │ │ │ ├── LICENSE
│ │ │ │ └── glob2/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── compat.py
│ │ │ │ ├── fnmatch.py
│ │ │ │ └── impl.py
│ │ │ ├── jinja2/
│ │ │ │ ├── LICENSE.rst
│ │ │ │ ├── README.rst
│ │ │ │ └── jinja2/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _compat.py
│ │ │ │ ├── _identifier.py
│ │ │ │ ├── bccache.py
│ │ │ │ ├── compiler.py
│ │ │ │ ├── constants.py
│ │ │ │ ├── debug.py
│ │ │ │ ├── defaults.py
│ │ │ │ ├── environment.py
│ │ │ │ ├── exceptions.py
│ │ │ │ ├── ext.py
│ │ │ │ ├── filters.py
│ │ │ │ ├── idtracking.py
│ │ │ │ ├── lexer.py
│ │ │ │ ├── loaders.py
│ │ │ │ ├── meta.py
│ │ │ │ ├── nativetypes.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── optimizer.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── runtime.py
│ │ │ │ ├── sandbox.py
│ │ │ │ ├── tests.py
│ │ │ │ ├── utils.py
│ │ │ │ └── visitor.py
│ │ │ ├── jinja2_35/
│ │ │ │ ├── LICENSE.rst
│ │ │ │ ├── README.rst
│ │ │ │ └── jinja2/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _compat.py
│ │ │ │ ├── _identifier.py
│ │ │ │ ├── bccache.py
│ │ │ │ ├── compiler.py
│ │ │ │ ├── constants.py
│ │ │ │ ├── debug.py
│ │ │ │ ├── defaults.py
│ │ │ │ ├── environment.py
│ │ │ │ ├── exceptions.py
│ │ │ │ ├── ext.py
│ │ │ │ ├── filters.py
│ │ │ │ ├── idtracking.py
│ │ │ │ ├── lexer.py
│ │ │ │ ├── loaders.py
│ │ │ │ ├── meta.py
│ │ │ │ ├── nativetypes.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── optimizer.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── runtime.py
│ │ │ │ ├── sandbox.py
│ │ │ │ ├── tests.py
│ │ │ │ ├── utils.py
│ │ │ │ └── visitor.py
│ │ │ ├── lib/
│ │ │ │ ├── scons-2.3.2/
│ │ │ │ │ └── SCons/
│ │ │ │ │ ├── Action.py
│ │ │ │ │ ├── Builder.py
│ │ │ │ │ ├── CacheDir.py
│ │ │ │ │ ├── Conftest.py
│ │ │ │ │ ├── Debug.py
│ │ │ │ │ ├── Defaults.py
│ │ │ │ │ ├── Environment.py
│ │ │ │ │ ├── Errors.py
│ │ │ │ │ ├── Executor.py
│ │ │ │ │ ├── Job.py
│ │ │ │ │ ├── Memoize.py
│ │ │ │ │ ├── Node/
│ │ │ │ │ │ ├── Alias.py
│ │ │ │ │ │ ├── FS.py
│ │ │ │ │ │ ├── Python.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Options/
│ │ │ │ │ │ ├── BoolOption.py
│ │ │ │ │ │ ├── EnumOption.py
│ │ │ │ │ │ ├── ListOption.py
│ │ │ │ │ │ ├── PackageOption.py
│ │ │ │ │ │ ├── PathOption.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── PathList.py
│ │ │ │ │ ├── Platform/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aix.py
│ │ │ │ │ │ ├── cygwin.py
│ │ │ │ │ │ ├── darwin.py
│ │ │ │ │ │ ├── hpux.py
│ │ │ │ │ │ ├── irix.py
│ │ │ │ │ │ ├── os2.py
│ │ │ │ │ │ ├── posix.py
│ │ │ │ │ │ ├── sunos.py
│ │ │ │ │ │ └── win32.py
│ │ │ │ │ ├── SConf.py
│ │ │ │ │ ├── SConsign.py
│ │ │ │ │ ├── Scanner/
│ │ │ │ │ │ ├── C.py
│ │ │ │ │ │ ├── Dir.py
│ │ │ │ │ │ ├── Prog.py
│ │ │ │ │ │ ├── RC.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Script/
│ │ │ │ │ │ ├── Interactive.py
│ │ │ │ │ │ ├── Main.py
│ │ │ │ │ │ ├── SConsOptions.py
│ │ │ │ │ │ ├── SConscript.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Sig.py
│ │ │ │ │ ├── Subst.py
│ │ │ │ │ ├── Taskmaster.py
│ │ │ │ │ ├── Tool/
│ │ │ │ │ │ ├── 386asm.py
│ │ │ │ │ │ ├── BitKeeper.py
│ │ │ │ │ │ ├── CVS.py
│ │ │ │ │ │ ├── GettextCommon.py
│ │ │ │ │ │ ├── MSCommon/
│ │ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ │ ├── arch.py
│ │ │ │ │ │ │ ├── common.py
│ │ │ │ │ │ │ ├── netframework.py
│ │ │ │ │ │ │ ├── sdk.py
│ │ │ │ │ │ │ ├── vc.py
│ │ │ │ │ │ │ └── vs.py
│ │ │ │ │ │ ├── Perforce.py
│ │ │ │ │ │ ├── PharLapCommon.py
│ │ │ │ │ │ ├── RCS.py
│ │ │ │ │ │ ├── SCCS.py
│ │ │ │ │ │ ├── Subversion.py
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aixc++.py
│ │ │ │ │ │ ├── aixcc.py
│ │ │ │ │ │ ├── aixf77.py
│ │ │ │ │ │ ├── aixlink.py
│ │ │ │ │ │ ├── applelink.py
│ │ │ │ │ │ ├── ar.py
│ │ │ │ │ │ ├── as.py
│ │ │ │ │ │ ├── bcc32.py
│ │ │ │ │ │ ├── c++.py
│ │ │ │ │ │ ├── cc.py
│ │ │ │ │ │ ├── cyglink.py
│ │ │ │ │ │ ├── default.py
│ │ │ │ │ │ ├── dmd.py
│ │ │ │ │ │ ├── docbook/
│ │ │ │ │ │ │ └── __init__.py
│ │ │ │ │ │ ├── filesystem.py
│ │ │ │ │ │ ├── g++.py
│ │ │ │ │ │ ├── g77.py
│ │ │ │ │ │ ├── gas.py
│ │ │ │ │ │ ├── gcc.py
│ │ │ │ │ │ ├── gdc.py
│ │ │ │ │ │ ├── gettext.py
│ │ │ │ │ │ ├── gfortran.py
│ │ │ │ │ │ ├── gnulink.py
│ │ │ │ │ │ ├── hpc++.py
│ │ │ │ │ │ ├── hpcc.py
│ │ │ │ │ │ ├── hplink.py
│ │ │ │ │ │ ├── icc.py
│ │ │ │ │ │ ├── icl.py
│ │ │ │ │ │ ├── ilink.py
│ │ │ │ │ │ ├── ilink32.py
│ │ │ │ │ │ ├── install.py
│ │ │ │ │ │ ├── intelc.py
│ │ │ │ │ │ ├── lex.py
│ │ │ │ │ │ ├── link.py
│ │ │ │ │ │ ├── linkloc.py
│ │ │ │ │ │ ├── m4.py
│ │ │ │ │ │ ├── masm.py
│ │ │ │ │ │ ├── mingw.py
│ │ │ │ │ │ ├── msgfmt.py
│ │ │ │ │ │ ├── msginit.py
│ │ │ │ │ │ ├── msgmerge.py
│ │ │ │ │ │ ├── mslib.py
│ │ │ │ │ │ ├── mslink.py
│ │ │ │ │ │ ├── mssdk.py
│ │ │ │ │ │ ├── msvc.py
│ │ │ │ │ │ ├── msvs.py
│ │ │ │ │ │ ├── mwcc.py
│ │ │ │ │ │ ├── mwld.py
│ │ │ │ │ │ ├── nasm.py
│ │ │ │ │ │ ├── rmic.py
│ │ │ │ │ │ ├── rpcgen.py
│ │ │ │ │ │ ├── sgiar.py
│ │ │ │ │ │ ├── sgic++.py
│ │ │ │ │ │ ├── sgicc.py
│ │ │ │ │ │ ├── sgilink.py
│ │ │ │ │ │ ├── sunar.py
│ │ │ │ │ │ ├── sunc++.py
│ │ │ │ │ │ ├── suncc.py
│ │ │ │ │ │ ├── sunlink.py
│ │ │ │ │ │ ├── tar.py
│ │ │ │ │ │ ├── textfile.py
│ │ │ │ │ │ ├── tlib.py
│ │ │ │ │ │ ├── wix.py
│ │ │ │ │ │ ├── xgettext.py
│ │ │ │ │ │ └── zip.py
│ │ │ │ │ ├── Util.py
│ │ │ │ │ ├── Variables/
│ │ │ │ │ │ ├── BoolVariable.py
│ │ │ │ │ │ ├── EnumVariable.py
│ │ │ │ │ │ ├── ListVariable.py
│ │ │ │ │ │ ├── PackageVariable.py
│ │ │ │ │ │ ├── PathVariable.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Warnings.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── compat/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── _scons_builtins.py
│ │ │ │ │ │ ├── _scons_collections.py
│ │ │ │ │ │ ├── _scons_dbm.py
│ │ │ │ │ │ ├── _scons_hashlib.py
│ │ │ │ │ │ ├── _scons_io.py
│ │ │ │ │ │ ├── _scons_sets.py
│ │ │ │ │ │ └── _scons_subprocess.py
│ │ │ │ │ ├── cpp.py
│ │ │ │ │ ├── dblite.py
│ │ │ │ │ └── exitfuncs.py
│ │ │ │ ├── scons-3.1.2/
│ │ │ │ │ └── SCons/
│ │ │ │ │ ├── Action.py
│ │ │ │ │ ├── Builder.py
│ │ │ │ │ ├── CacheDir.py
│ │ │ │ │ ├── Conftest.py
│ │ │ │ │ ├── Debug.py
│ │ │ │ │ ├── Defaults.py
│ │ │ │ │ ├── Environment.py
│ │ │ │ │ ├── Errors.py
│ │ │ │ │ ├── Executor.py
│ │ │ │ │ ├── Job.py
│ │ │ │ │ ├── Memoize.py
│ │ │ │ │ ├── Node/
│ │ │ │ │ │ ├── Alias.py
│ │ │ │ │ │ ├── FS.py
│ │ │ │ │ │ ├── Python.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── PathList.py
│ │ │ │ │ ├── Platform/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aix.py
│ │ │ │ │ │ ├── cygwin.py
│ │ │ │ │ │ ├── darwin.py
│ │ │ │ │ │ ├── hpux.py
│ │ │ │ │ │ ├── irix.py
│ │ │ │ │ │ ├── mingw.py
│ │ │ │ │ │ ├── os2.py
│ │ │ │ │ │ ├── posix.py
│ │ │ │ │ │ ├── sunos.py
│ │ │ │ │ │ ├── virtualenv.py
│ │ │ │ │ │ └── win32.py
│ │ │ │ │ ├── SConf.py
│ │ │ │ │ ├── SConsign.py
│ │ │ │ │ ├── Scanner/
│ │ │ │ │ │ ├── C.py
│ │ │ │ │ │ ├── Dir.py
│ │ │ │ │ │ ├── Prog.py
│ │ │ │ │ │ ├── RC.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Script/
│ │ │ │ │ │ ├── Interactive.py
│ │ │ │ │ │ ├── Main.py
│ │ │ │ │ │ ├── SConsOptions.py
│ │ │ │ │ │ ├── SConscript.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Subst.py
│ │ │ │ │ ├── Taskmaster.py
│ │ │ │ │ ├── Tool/
│ │ │ │ │ │ ├── 386asm.py
│ │ │ │ │ │ ├── GettextCommon.py
│ │ │ │ │ │ ├── MSCommon/
│ │ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ │ ├── arch.py
│ │ │ │ │ │ │ ├── common.py
│ │ │ │ │ │ │ ├── netframework.py
│ │ │ │ │ │ │ ├── sdk.py
│ │ │ │ │ │ │ ├── vc.py
│ │ │ │ │ │ │ └── vs.py
│ │ │ │ │ │ ├── PharLapCommon.py
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── aixc++.py
│ │ │ │ │ │ ├── aixcc.py
│ │ │ │ │ │ ├── aixcxx.py
│ │ │ │ │ │ ├── aixlink.py
│ │ │ │ │ │ ├── applelink.py
│ │ │ │ │ │ ├── ar.py
│ │ │ │ │ │ ├── as.py
│ │ │ │ │ │ ├── bcc32.py
│ │ │ │ │ │ ├── c++.py
│ │ │ │ │ │ ├── cc.py
│ │ │ │ │ │ ├── clang.py
│ │ │ │ │ │ ├── clangCommon/
│ │ │ │ │ │ │ └── __init__.py
│ │ │ │ │ │ ├── clangxx.py
│ │ │ │ │ │ ├── cxx.py
│ │ │ │ │ │ ├── cyglink.py
│ │ │ │ │ │ ├── default.py
│ │ │ │ │ │ ├── docbook/
│ │ │ │ │ │ │ └── __init__.py
│ │ │ │ │ │ ├── filesystem.py
│ │ │ │ │ │ ├── g++.py
│ │ │ │ │ │ ├── gas.py
│ │ │ │ │ │ ├── gcc.py
│ │ │ │ │ │ ├── gettext_tool.py
│ │ │ │ │ │ ├── gnulink.py
│ │ │ │ │ │ ├── gxx.py
│ │ │ │ │ │ ├── hpc++.py
│ │ │ │ │ │ ├── hpcc.py
│ │ │ │ │ │ ├── hpcxx.py
│ │ │ │ │ │ ├── hplink.py
│ │ │ │ │ │ ├── icc.py
│ │ │ │ │ │ ├── icl.py
│ │ │ │ │ │ ├── ilink.py
│ │ │ │ │ │ ├── ilink32.py
│ │ │ │ │ │ ├── install.py
│ │ │ │ │ │ ├── intelc.py
│ │ │ │ │ │ ├── link.py
│ │ │ │ │ │ ├── linkloc.py
│ │ │ │ │ │ ├── m4.py
│ │ │ │ │ │ ├── masm.py
│ │ │ │ │ │ ├── mingw.py
│ │ │ │ │ │ ├── msgfmt.py
│ │ │ │ │ │ ├── msginit.py
│ │ │ │ │ │ ├── msgmerge.py
│ │ │ │ │ │ ├── mslib.py
│ │ │ │ │ │ ├── mslink.py
│ │ │ │ │ │ ├── mssdk.py
│ │ │ │ │ │ ├── msvc.py
│ │ │ │ │ │ ├── msvs.py
│ │ │ │ │ │ ├── mwcc.py
│ │ │ │ │ │ ├── mwld.py
│ │ │ │ │ │ ├── nasm.py
│ │ │ │ │ │ ├── rmic.py
│ │ │ │ │ │ ├── rpcgen.py
│ │ │ │ │ │ ├── sgiar.py
│ │ │ │ │ │ ├── sgic++.py
│ │ │ │ │ │ ├── sgicc.py
│ │ │ │ │ │ ├── sgicxx.py
│ │ │ │ │ │ ├── sgilink.py
│ │ │ │ │ │ ├── sunar.py
│ │ │ │ │ │ ├── sunc++.py
│ │ │ │ │ │ ├── suncc.py
│ │ │ │ │ │ ├── suncxx.py
│ │ │ │ │ │ ├── sunlink.py
│ │ │ │ │ │ ├── tar.py
│ │ │ │ │ │ ├── textfile.py
│ │ │ │ │ │ ├── tlib.py
│ │ │ │ │ │ ├── wix.py
│ │ │ │ │ │ ├── xgettext.py
│ │ │ │ │ │ └── zip.py
│ │ │ │ │ ├── Util.py
│ │ │ │ │ ├── Variables/
│ │ │ │ │ │ ├── BoolVariable.py
│ │ │ │ │ │ ├── EnumVariable.py
│ │ │ │ │ │ ├── ListVariable.py
│ │ │ │ │ │ ├── PackageVariable.py
│ │ │ │ │ │ ├── PathVariable.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── Warnings.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── compat/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ └── _scons_dbm.py
│ │ │ │ │ ├── cpp.py
│ │ │ │ │ ├── dblite.py
│ │ │ │ │ └── exitfuncs.py
│ │ │ │ └── scons-4.3.0/
│ │ │ │ └── SCons/
│ │ │ │ ├── Action.py
│ │ │ │ ├── Builder.py
│ │ │ │ ├── CacheDir.py
│ │ │ │ ├── Conftest.py
│ │ │ │ ├── Debug.py
│ │ │ │ ├── Defaults.py
│ │ │ │ ├── Environment.py
│ │ │ │ ├── EnvironmentValues.py
│ │ │ │ ├── Errors.py
│ │ │ │ ├── Executor.py
│ │ │ │ ├── Job.py
│ │ │ │ ├── Memoize.py
│ │ │ │ ├── Node/
│ │ │ │ │ ├── Alias.py
│ │ │ │ │ ├── FS.py
│ │ │ │ │ ├── Python.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── PathList.py
│ │ │ │ ├── Platform/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── aix.py
│ │ │ │ │ ├── cygwin.py
│ │ │ │ │ ├── darwin.py
│ │ │ │ │ ├── hpux.py
│ │ │ │ │ ├── irix.py
│ │ │ │ │ ├── mingw.py
│ │ │ │ │ ├── os2.py
│ │ │ │ │ ├── posix.py
│ │ │ │ │ ├── sunos.py
│ │ │ │ │ ├── virtualenv.py
│ │ │ │ │ └── win32.py
│ │ │ │ ├── SConf.py
│ │ │ │ ├── SConsign.py
│ │ │ │ ├── Scanner/
│ │ │ │ │ ├── C.py
│ │ │ │ │ ├── Dir.py
│ │ │ │ │ ├── Prog.py
│ │ │ │ │ ├── RC.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── Script/
│ │ │ │ │ ├── Interactive.py
│ │ │ │ │ ├── Main.py
│ │ │ │ │ ├── SConsOptions.py
│ │ │ │ │ ├── SConscript.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── Subst.py
│ │ │ │ ├── Taskmaster.py
│ │ │ │ ├── Tool/
│ │ │ │ │ ├── 386asm.py
│ │ │ │ │ ├── GettextCommon.py
│ │ │ │ │ ├── MSCommon/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── arch.py
│ │ │ │ │ │ ├── common.py
│ │ │ │ │ │ ├── netframework.py
│ │ │ │ │ │ ├── sdk.py
│ │ │ │ │ │ ├── vc.py
│ │ │ │ │ │ └── vs.py
│ │ │ │ │ ├── PharLapCommon.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── aixc++.py
│ │ │ │ │ ├── aixcc.py
│ │ │ │ │ ├── aixcxx.py
│ │ │ │ │ ├── aixlink.py
│ │ │ │ │ ├── applelink.py
│ │ │ │ │ ├── ar.py
│ │ │ │ │ ├── as.py
│ │ │ │ │ ├── asm.py
│ │ │ │ │ ├── bcc32.py
│ │ │ │ │ ├── c++.py
│ │ │ │ │ ├── cc.py
│ │ │ │ │ ├── clang.py
│ │ │ │ │ ├── clangCommon/
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── clangxx.py
│ │ │ │ │ ├── cxx.py
│ │ │ │ │ ├── cyglink.py
│ │ │ │ │ ├── default.py
│ │ │ │ │ ├── filesystem.py
│ │ │ │ │ ├── g++.py
│ │ │ │ │ ├── gas.py
│ │ │ │ │ ├── gcc.py
│ │ │ │ │ ├── gettext_tool.py
│ │ │ │ │ ├── gnulink.py
│ │ │ │ │ ├── gxx.py
│ │ │ │ │ ├── hpc++.py
│ │ │ │ │ ├── hpcc.py
│ │ │ │ │ ├── hpcxx.py
│ │ │ │ │ ├── hplink.py
│ │ │ │ │ ├── icc.py
│ │ │ │ │ ├── icl.py
│ │ │ │ │ ├── ilink.py
│ │ │ │ │ ├── ilink32.py
│ │ │ │ │ ├── install.py
│ │ │ │ │ ├── intelc.py
│ │ │ │ │ ├── link.py
│ │ │ │ │ ├── linkCommon/
│ │ │ │ │ │ ├── LoadableModule.py
│ │ │ │ │ │ ├── SharedLibrary.py
│ │ │ │ │ │ └── __init__.py
│ │ │ │ │ ├── linkloc.py
│ │ │ │ │ ├── m4.py
│ │ │ │ │ ├── masm.py
│ │ │ │ │ ├── mingw.py
│ │ │ │ │ ├── msgfmt.py
│ │ │ │ │ ├── msginit.py
│ │ │ │ │ ├── msgmerge.py
│ │ │ │ │ ├── mslib.py
│ │ │ │ │ ├── mslink.py
│ │ │ │ │ ├── mssdk.py
│ │ │ │ │ ├── msvc.py
│ │ │ │ │ ├── msvs.py
│ │ │ │ │ ├── mwcc.py
│ │ │ │ │ ├── mwld.py
│ │ │ │ │ ├── nasm.py
│ │ │ │ │ ├── rmic.py
│ │ │ │ │ ├── rpcgen.py
│ │ │ │ │ ├── sgiar.py
│ │ │ │ │ ├── sgic++.py
│ │ │ │ │ ├── sgicc.py
│ │ │ │ │ ├── sgicxx.py
│ │ │ │ │ ├── sgilink.py
│ │ │ │ │ ├── sunar.py
│ │ │ │ │ ├── sunc++.py
│ │ │ │ │ ├── suncc.py
│ │ │ │ │ ├── suncxx.py
│ │ │ │ │ ├── sunlink.py
│ │ │ │ │ ├── tar.py
│ │ │ │ │ ├── textfile.py
│ │ │ │ │ ├── tlib.py
│ │ │ │ │ ├── wix.py
│ │ │ │ │ ├── xgettext.py
│ │ │ │ │ └── zip.py
│ │ │ │ ├── Util.py
│ │ │ │ ├── Utilities/
│ │ │ │ │ ├── ConfigureCache.py
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── sconsign.py
│ │ │ │ ├── Variables/
│ │ │ │ │ ├── BoolVariable.py
│ │ │ │ │ ├── EnumVariable.py
│ │ │ │ │ ├── ListVariable.py
│ │ │ │ │ ├── PackageVariable.py
│ │ │ │ │ ├── PathVariable.py
│ │ │ │ │ └── __init__.py
│ │ │ │ ├── Warnings.py
│ │ │ │ ├── __init__.py
│ │ │ │ ├── compat/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── _scons_dbm.py
│ │ │ │ │ └── win32.py
│ │ │ │ ├── cpp.py
│ │ │ │ ├── dblite.py
│ │ │ │ └── exitfuncs.py
│ │ │ ├── libbacktrace/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README.md
│ │ │ │ └── backtrace/
│ │ │ │ ├── alloc.c
│ │ │ │ ├── backtrace-supported.h
│ │ │ │ ├── backtrace.c
│ │ │ │ ├── backtrace.h
│ │ │ │ ├── config.h
│ │ │ │ ├── dwarf.c
│ │ │ │ ├── elf.c
│ │ │ │ ├── fileline.c
│ │ │ │ ├── filenames.h
│ │ │ │ ├── internal.h
│ │ │ │ ├── macho.c
│ │ │ │ ├── mmap.c
│ │ │ │ ├── pecoff.c
│ │ │ │ ├── posix.c
│ │ │ │ ├── read.c
│ │ │ │ ├── sort.c
│ │ │ │ ├── state.c
│ │ │ │ └── xcoff.c
│ │ │ ├── markupsafe/
│ │ │ │ ├── LICENSE.rst
│ │ │ │ └── markupsafe/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _compat.py
│ │ │ │ ├── _constants.py
│ │ │ │ └── _native.py
│ │ │ ├── pkg_resources/
│ │ │ │ └── pkg_resources/
│ │ │ │ ├── __init__.py
│ │ │ │ └── py31compat.py
│ │ │ ├── pkg_resources_27/
│ │ │ │ └── pkg_resources/
│ │ │ │ └── __init__.py
│ │ │ ├── tqdm/
│ │ │ │ ├── LICENCE
│ │ │ │ └── tqdm/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── _main.py
│ │ │ │ ├── _monitor.py
│ │ │ │ ├── _tqdm.py
│ │ │ │ ├── _tqdm_notebook.py
│ │ │ │ ├── _tqdm_pandas.py
│ │ │ │ ├── _utils.py
│ │ │ │ ├── auto.py
│ │ │ │ ├── autonotebook.py
│ │ │ │ ├── dask.py
│ │ │ │ ├── notebook.py
│ │ │ │ ├── std.py
│ │ │ │ ├── tk.py
│ │ │ │ ├── utils.py
│ │ │ │ └── version.py
│ │ │ ├── wax_off/
│ │ │ │ ├── LICENSE
│ │ │ │ └── wax_off.py
│ │ │ ├── yaml/
│ │ │ │ ├── LICENSE
│ │ │ │ └── yaml/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── composer.py
│ │ │ │ ├── constructor.py
│ │ │ │ ├── cyaml.py
│ │ │ │ ├── dumper.py
│ │ │ │ ├── emitter.py
│ │ │ │ ├── error.py
│ │ │ │ ├── events.py
│ │ │ │ ├── loader.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── reader.py
│ │ │ │ ├── representer.py
│ │ │ │ ├── resolver.py
│ │ │ │ ├── scanner.py
│ │ │ │ ├── serializer.py
│ │ │ │ └── tokens.py
│ │ │ ├── yaml_27/
│ │ │ │ ├── LICENSE
│ │ │ │ └── yaml/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── composer.py
│ │ │ │ ├── constructor.py
│ │ │ │ ├── cyaml.py
│ │ │ │ ├── dumper.py
│ │ │ │ ├── emitter.py
│ │ │ │ ├── error.py
│ │ │ │ ├── events.py
│ │ │ │ ├── loader.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── reader.py
│ │ │ │ ├── representer.py
│ │ │ │ ├── resolver.py
│ │ │ │ ├── scanner.py
│ │ │ │ ├── serializer.py
│ │ │ │ └── tokens.py
│ │ │ ├── yaml_35/
│ │ │ │ ├── LICENSE
│ │ │ │ └── yaml/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── composer.py
│ │ │ │ ├── constructor.py
│ │ │ │ ├── cyaml.py
│ │ │ │ ├── dumper.py
│ │ │ │ ├── emitter.py
│ │ │ │ ├── error.py
│ │ │ │ ├── events.py
│ │ │ │ ├── loader.py
│ │ │ │ ├── nodes.py
│ │ │ │ ├── parser.py
│ │ │ │ ├── reader.py
│ │ │ │ ├── representer.py
│ │ │ │ ├── resolver.py
│ │ │ │ ├── scanner.py
│ │ │ │ ├── serializer.py
│ │ │ │ └── tokens.py
│ │ │ ├── zlib/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── crc32.c
│ │ │ │ ├── crc32.h
│ │ │ │ ├── zconf.h
│ │ │ │ ├── zlib.h
│ │ │ │ └── zutil.h
│ │ │ └── zstd/
│ │ │ ├── LICENSE.txt
│ │ │ ├── common/
│ │ │ │ ├── bitstream.h
│ │ │ │ ├── compiler.h
│ │ │ │ ├── cpu.h
│ │ │ │ ├── debug.h
│ │ │ │ ├── entropy_common.c
│ │ │ │ ├── error_private.c
│ │ │ │ ├── error_private.h
│ │ │ │ ├── fse.h
│ │ │ │ ├── fse_decompress.c
│ │ │ │ ├── huf.h
│ │ │ │ ├── mem.h
│ │ │ │ ├── xxhash.c
│ │ │ │ ├── xxhash.h
│ │ │ │ ├── zstd_common.c
│ │ │ │ ├── zstd_deps.h
│ │ │ │ ├── zstd_errors.h
│ │ │ │ └── zstd_internal.h
│ │ │ ├── decompress/
│ │ │ │ ├── huf_decompress.c
│ │ │ │ ├── zstd_ddict.c
│ │ │ │ ├── zstd_ddict.h
│ │ │ │ ├── zstd_decompress.c
│ │ │ │ ├── zstd_decompress_block.c
│ │ │ │ ├── zstd_decompress_block.h
│ │ │ │ └── zstd_decompress_internal.h
│ │ │ └── zstd.h
│ │ └── static_src/
│ │ ├── CompiledAsyncgenType.c
│ │ ├── CompiledCellType.c
│ │ ├── CompiledCodeHelpers.c
│ │ ├── CompiledCoroutineType.c
│ │ ├── CompiledFrameType.c
│ │ ├── CompiledFunctionType.c
│ │ ├── CompiledGeneratorType.c
│ │ ├── CompiledGeneratorTypeUncompiledIntegration.c
│ │ ├── CompiledMethodType.c
│ │ ├── HelpersAllocator.c
│ │ ├── HelpersAttributes.c
│ │ ├── HelpersBuiltin.c
│ │ ├── HelpersBuiltinTypeMethods.c
│ │ ├── HelpersBytes.c
│ │ ├── HelpersCalling.c
│ │ ├── HelpersCallingGenerated.c
│ │ ├── HelpersChecksumTools.c
│ │ ├── HelpersClasses.c
│ │ ├── HelpersComparisonEq.c
│ │ ├── HelpersComparisonEqUtils.c
│ │ ├── HelpersComparisonGe.c
│ │ ├── HelpersComparisonGt.c
│ │ ├── HelpersComparisonLe.c
│ │ ├── HelpersComparisonLt.c
│ │ ├── HelpersComparisonNe.c
│ │ ├── HelpersConstantsBlob.c
│ │ ├── HelpersDeepcopy.c
│ │ ├── HelpersDictionaries.c
│ │ ├── HelpersDictionariesGenerated.c
│ │ ├── HelpersDumpBacktraces.c
│ │ ├── HelpersEnvironmentVariables.c
│ │ ├── HelpersEnvironmentVariablesSystem.c
│ │ ├── HelpersExceptions.c
│ │ ├── HelpersFiles.c
│ │ ├── HelpersFilesystemPaths.c
│ │ ├── HelpersFloats.c
│ │ ├── HelpersHeapStorage.c
│ │ ├── HelpersImport.c
│ │ ├── HelpersImportHard.c
│ │ ├── HelpersJitSources.c
│ │ ├── HelpersLists.c
│ │ ├── HelpersListsGenerated.c
│ │ ├── HelpersMappings.c
│ │ ├── HelpersMatching.c
│ │ ├── HelpersOperationBinaryAdd.c
│ │ ├── HelpersOperationBinaryAddUtils.c
│ │ ├── HelpersOperationBinaryBitand.c
│ │ ├── HelpersOperationBinaryBitor.c
│ │ ├── HelpersOperationBinaryBitxor.c
│ │ ├── HelpersOperationBinaryDivmod.c
│ │ ├── HelpersOperationBinaryDivmodUtils.c
│ │ ├── HelpersOperationBinaryFloordiv.c
│ │ ├── HelpersOperationBinaryInplaceAdd.c
│ │ ├── HelpersOperationBinaryLshift.c
│ │ ├── HelpersOperationBinaryMatmult.c
│ │ ├── HelpersOperationBinaryMod.c
│ │ ├── HelpersOperationBinaryMult.c
│ │ ├── HelpersOperationBinaryMultUtils.c
│ │ ├── HelpersOperationBinaryOlddiv.c
│ │ ├── HelpersOperationBinaryPow.c
│ │ ├── HelpersOperationBinaryPowUtils.c
│ │ ├── HelpersOperationBinaryRshift.c
│ │ ├── HelpersOperationBinarySub.c
│ │ ├── HelpersOperationBinaryTruediv.c
│ │ ├── HelpersOperationInplaceAdd.c
│ │ ├── HelpersOperationInplaceAddUtils.c
│ │ ├── HelpersOperationInplaceBitand.c
│ │ ├── HelpersOperationInplaceBitor.c
│ │ ├── HelpersOperationInplaceBitxor.c
│ │ ├── HelpersOperationInplaceFloordiv.c
│ │ ├── HelpersOperationInplaceLshift.c
│ │ ├── HelpersOperationInplaceMatmult.c
│ │ ├── HelpersOperationInplaceMod.c
│ │ ├── HelpersOperationInplaceMult.c
│ │ ├── HelpersOperationInplaceOlddiv.c
│ │ ├── HelpersOperationInplacePow.c
│ │ ├── HelpersOperationInplaceRshift.c
│ │ ├── HelpersOperationInplaceSub.c
│ │ ├── HelpersOperationInplaceTruediv.c
│ │ ├── HelpersProfiling.c
│ │ ├── HelpersPythonPgo.c
│ │ ├── HelpersRaising.c
│ │ ├── HelpersSafeStrings.c
│ │ ├── HelpersSequences.c
│ │ ├── HelpersSlices.c
│ │ ├── HelpersStrings.c
│ │ ├── HelpersTuples.c
│ │ ├── HelpersTypes.c
│ │ ├── InspectPatcher.c
│ │ ├── MainProgram.c
│ │ ├── MetaPathBasedLoader.c
│ │ ├── MetaPathBasedLoaderImportlibMetadataDistribution.c
│ │ ├── MetaPathBasedLoaderResourceReader.c
│ │ ├── MetaPathBasedLoaderResourceReaderFiles.c
│ │ ├── OnefileBootstrap.c
│ │ └── OnefileSplashScreen.cpp
│ ├── code_generation/
│ │ ├── AsyncgenCodes.py
│ │ ├── AttributeCodes.py
│ │ ├── BinaryOperationHelperDefinitions.py
│ │ ├── BranchCodes.py
│ │ ├── BuiltinCodes.py
│ │ ├── CallCodes.py
│ │ ├── ClassCodes.py
│ │ ├── CodeGeneration.py
│ │ ├── CodeHelperSelection.py
│ │ ├── CodeHelpers.py
│ │ ├── CodeObjectCodes.py
│ │ ├── ComparisonCodes.py
│ │ ├── ComparisonHelperDefinitions.py
│ │ ├── ConditionalCodes.py
│ │ ├── ConstantCodes.py
│ │ ├── Contexts.py
│ │ ├── CoroutineCodes.py
│ │ ├── CtypesCodes.py
│ │ ├── DictCodes.py
│ │ ├── Emission.py
│ │ ├── ErrorCodes.py
│ │ ├── EvalCodes.py
│ │ ├── ExceptionCodes.py
│ │ ├── ExpressionCTypeSelectionHelpers.py
│ │ ├── ExpressionCodes.py
│ │ ├── FrameCodes.py
│ │ ├── FunctionCodes.py
│ │ ├── GeneratorCodes.py
│ │ ├── GlobalConstants.py
│ │ ├── GlobalsLocalsCodes.py
│ │ ├── IdCodes.py
│ │ ├── ImportCodes.py
│ │ ├── Indentation.py
│ │ ├── IndexCodes.py
│ │ ├── InjectCCodes.py
│ │ ├── IntegerCodes.py
│ │ ├── IteratorCodes.py
│ │ ├── LabelCodes.py
│ │ ├── LineNumberCodes.py
│ │ ├── ListCodes.py
│ │ ├── LoaderCodes.py
│ │ ├── LocalsDictCodes.py
│ │ ├── LoopCodes.py
│ │ ├── MatchCodes.py
│ │ ├── ModuleCodes.py
│ │ ├── Namify.py
│ │ ├── OperationCodes.py
│ │ ├── PackageResourceCodes.py
│ │ ├── PrintCodes.py
│ │ ├── PythonAPICodes.py
│ │ ├── RaisingCodes.py
│ │ ├── Reports.py
│ │ ├── ReturnCodes.py
│ │ ├── SetCodes.py
│ │ ├── SliceCodes.py
│ │ ├── StringCodes.py
│ │ ├── SubscriptCodes.py
│ │ ├── TensorflowCodes.py
│ │ ├── TryCodes.py
│ │ ├── TupleCodes.py
│ │ ├── VariableCodes.py
│ │ ├── VariableDeclarations.py
│ │ ├── YieldCodes.py
│ │ ├── __init__.py
│ │ ├── c_types/
│ │ │ ├── CTypeBases.py
│ │ │ ├── CTypeBooleans.py
│ │ │ ├── CTypeCFloats.py
│ │ │ ├── CTypeCLongs.py
│ │ │ ├── CTypeModuleDictVariables.py
│ │ │ ├── CTypeNuitkaBooleans.py
│ │ │ ├── CTypeNuitkaInts.py
│ │ │ ├── CTypeNuitkaVoids.py
│ │ │ ├── CTypePyObjectPointers.py
│ │ │ ├── CTypeVoids.py
│ │ │ └── __init__.py
│ │ ├── templates/
│ │ │ ├── CodeTemplatesAsyncgens.py
│ │ │ ├── CodeTemplatesConstants.py
│ │ │ ├── CodeTemplatesCoroutines.py
│ │ │ ├── CodeTemplatesExceptions.py
│ │ │ ├── CodeTemplatesFrames.py
│ │ │ ├── CodeTemplatesFunction.py
│ │ │ ├── CodeTemplatesGeneratorFunction.py
│ │ │ ├── CodeTemplatesIterators.py
│ │ │ ├── CodeTemplatesLoader.py
│ │ │ ├── CodeTemplatesModules.py
│ │ │ ├── CodeTemplatesVariables.py
│ │ │ ├── TemplateDebugWrapper.py
│ │ │ └── __init__.py
│ │ └── templates_c/
│ │ ├── CodeTemplateCallsMethodPositional.c.j2
│ │ ├── CodeTemplateCallsMixed.c.j2
│ │ ├── CodeTemplateCallsPositional.c.j2
│ │ ├── CodeTemplateCallsPositionalMethodDescr.c.j2
│ │ ├── CodeTemplateMakeListHinted.c.j2
│ │ ├── CodeTemplateMakeListSmall.c.j2
│ │ ├── HelperBuiltinMethodOperation.c.j2
│ │ ├── HelperDictionaryCopy.c.j2
│ │ ├── HelperImportHard.c.j2
│ │ ├── HelperLongTools.c.j2
│ │ ├── HelperObjectTools.c.j2
│ │ ├── HelperOperationBinary.c.j2
│ │ ├── HelperOperationComparison.c.j2
│ │ ├── HelperOperationComparisonBytes.c.j2
│ │ ├── HelperOperationComparisonFloat.c.j2
│ │ ├── HelperOperationComparisonInt.c.j2
│ │ ├── HelperOperationComparisonList.c.j2
│ │ ├── HelperOperationComparisonLong.c.j2
│ │ ├── HelperOperationComparisonStr.c.j2
│ │ ├── HelperOperationComparisonTuple.c.j2
│ │ ├── HelperOperationComparisonUnicode.c.j2
│ │ ├── HelperOperationInplace.c.j2
│ │ ├── HelperSlotsBinary.c.j2
│ │ ├── HelperSlotsBytes.c.j2
│ │ ├── HelperSlotsCommon.c.j2
│ │ ├── HelperSlotsFloat.c.j2
│ │ ├── HelperSlotsInt.c.j2
│ │ ├── HelperSlotsList.c.j2
│ │ ├── HelperSlotsLong.c.j2
│ │ ├── HelperSlotsSet.c.j2
│ │ ├── HelperSlotsStr.c.j2
│ │ ├── HelperSlotsTuple.c.j2
│ │ └── HelperSlotsUnicode.c.j2
│ ├── containers/
│ │ ├── Namedtuples.py
│ │ ├── OrderedDicts.py
│ │ ├── OrderedSets.py
│ │ ├── OrderedSetsFallback.py
│ │ └── __init__.py
│ ├── distutils/
│ │ ├── Build.py
│ │ ├── DistutilCommands.py
│ │ └── __init__.py
│ ├── finalizations/
│ │ ├── Finalization.py
│ │ ├── FinalizeMarkups.py
│ │ └── __init__.py
│ ├── freezer/
│ │ ├── DependsExe.py
│ │ ├── DllDependenciesCommon.py
│ │ ├── DllDependenciesMacOS.py
│ │ ├── DllDependenciesPosix.py
│ │ ├── DllDependenciesWin32.py
│ │ ├── ImportDetection.py
│ │ ├── IncludedDataFiles.py
│ │ ├── IncludedEntryPoints.py
│ │ ├── Onefile.py
│ │ ├── Standalone.py
│ │ └── __init__.py
│ ├── importing/
│ │ ├── IgnoreListing.py
│ │ ├── ImportCache.py
│ │ ├── ImportResolving.py
│ │ ├── Importing.py
│ │ ├── PreloadedPackages.py
│ │ ├── Recursion.py
│ │ ├── StandardLibrary.py
│ │ └── __init__.py
│ ├── nodes/
│ │ ├── AsyncgenNodes.py
│ │ ├── AttributeLookupNodes.py
│ │ ├── AttributeNodes.py
│ │ ├── AttributeNodesGenerated.py
│ │ ├── BuiltinAllNodes.py
│ │ ├── BuiltinAnyNodes.py
│ │ ├── BuiltinComplexNodes.py
│ │ ├── BuiltinDecodingNodes.py
│ │ ├── BuiltinDecoratorNodes.py
│ │ ├── BuiltinDictNodes.py
│ │ ├── BuiltinFormatNodes.py
│ │ ├── BuiltinHashNodes.py
│ │ ├── BuiltinInputNodes.py
│ │ ├── BuiltinIntegerNodes.py
│ │ ├── BuiltinIteratorNodes.py
│ │ ├── BuiltinLenNodes.py
│ │ ├── BuiltinNextNodes.py
│ │ ├── BuiltinOpenNodes.py
│ │ ├── BuiltinOperationNodeBasesGenerated.py
│ │ ├── BuiltinRangeNodes.py
│ │ ├── BuiltinRefNodes.py
│ │ ├── BuiltinSumNodes.py
│ │ ├── BuiltinTypeNodes.py
│ │ ├── BuiltinVarsNodes.py
│ │ ├── BytesNodes.py
│ │ ├── CallNodes.py
│ │ ├── Checkers.py
│ │ ├── ChildrenHavingMixins.py
│ │ ├── ClassNodes.py
│ │ ├── CodeObjectSpecs.py
│ │ ├── ComparisonNodes.py
│ │ ├── ConditionalNodes.py
│ │ ├── ConstantRefNodes.py
│ │ ├── ContainerMakingNodes.py
│ │ ├── ContainerOperationNodes.py
│ │ ├── CoroutineNodes.py
│ │ ├── CtypesNodes.py
│ │ ├── DictionaryNodes.py
│ │ ├── ExceptionNodes.py
│ │ ├── ExecEvalNodes.py
│ │ ├── ExpressionBases.py
│ │ ├── ExpressionBasesGenerated.py
│ │ ├── ExpressionShapeMixins.py
│ │ ├── FrameNodes.py
│ │ ├── FunctionAttributeNodes.py
│ │ ├── FunctionNodes.py
│ │ ├── FutureSpecs.py
│ │ ├── GeneratorNodes.py
│ │ ├── GlobalsLocalsNodes.py
│ │ ├── HardImportNodesGenerated.py
│ │ ├── ImportHardNodes.py
│ │ ├── ImportNodes.py
│ │ ├── IndicatorMixins.py
│ │ ├── InjectCNodes.py
│ │ ├── IterationHandles.py
│ │ ├── KeyValuePairNodes.py
│ │ ├── ListOperationNodes.py
│ │ ├── LocalsDictNodes.py
│ │ ├── LocalsScopes.py
│ │ ├── LoopNodes.py
│ │ ├── MatchNodes.py
│ │ ├── ModuleAttributeNodes.py
│ │ ├── ModuleNodes.py
│ │ ├── NodeBases.py
│ │ ├── NodeMakingHelpers.py
│ │ ├── NodeMetaClasses.py
│ │ ├── OperatorNodes.py
│ │ ├── OperatorNodesUnary.py
│ │ ├── OsSysNodes.py
│ │ ├── OutlineNodes.py
│ │ ├── PackageMetadataNodes.py
│ │ ├── PackageResourceNodes.py
│ │ ├── PrintNodes.py
│ │ ├── ReturnNodes.py
│ │ ├── SideEffectNodes.py
│ │ ├── SliceNodes.py
│ │ ├── StatementBasesGenerated.py
│ │ ├── StatementNodes.py
│ │ ├── StrNodes.py
│ │ ├── StringConcatenationNodes.py
│ │ ├── SubscriptNodes.py
│ │ ├── TensorflowNodes.py
│ │ ├── TryNodes.py
│ │ ├── TypeMatchNodes.py
│ │ ├── TypeNodes.py
│ │ ├── VariableAssignNodes.py
│ │ ├── VariableDelNodes.py
│ │ ├── VariableNameNodes.py
│ │ ├── VariableRefNodes.py
│ │ ├── VariableReleaseNodes.py
│ │ ├── YieldNodes.py
│ │ ├── __init__.py
│ │ └── shapes/
│ │ ├── BuiltinTypeShapes.py
│ │ ├── ControlFlowDescriptions.py
│ │ ├── ShapeMixins.py
│ │ ├── StandardShapes.py
│ │ └── __init__.py
│ ├── optimizations/
│ │ ├── BytecodeDemotion.py
│ │ ├── FunctionInlining.py
│ │ ├── Graphs.py
│ │ ├── Optimization.py
│ │ ├── OptimizeBuiltinCalls.py
│ │ ├── Tags.py
│ │ ├── TraceCollections.py
│ │ ├── ValueTraces.py
│ │ └── __init__.py
│ ├── pgo/
│ │ ├── PGO.py
│ │ └── __init__.py
│ ├── plugins/
│ │ ├── PluginBase.py
│ │ ├── Plugins.py
│ │ ├── __init__.py
│ │ └── standard/
│ │ ├── AntiBloatPlugin.py
│ │ ├── ConsiderPyLintAnnotationsPlugin.py
│ │ ├── DataFilesPlugin.py
│ │ ├── DelvewheelPlugin.py
│ │ ├── DillPlugin/
│ │ │ ├── DillPlugin.c
│ │ │ └── dill-postLoad.py
│ │ ├── DillPlugin.py
│ │ ├── DllFilesPlugin.py
│ │ ├── EnumPlugin.py
│ │ ├── EventletPlugin.py
│ │ ├── GeventPlugin.py
│ │ ├── GiPlugin.py
│ │ ├── GlfwPlugin.py
│ │ ├── ImplicitImports.py
│ │ ├── KivyPlugin.py
│ │ ├── MatplotlibPlugin.py
│ │ ├── MultiprocessingPlugin.py
│ │ ├── NumpyPlugin.py
│ │ ├── OptionsNannyPlugin.py
│ │ ├── PbrPlugin.py
│ │ ├── PkgResourcesPlugin.py
│ │ ├── PmwPlugin.py
│ │ ├── PySidePyQtPlugin.py
│ │ ├── PywebViewPlugin.py
│ │ ├── TensorflowPlugin.py
│ │ ├── TkinterPlugin.py
│ │ ├── TorchPlugin.py
│ │ ├── TransformersPlugin.py
│ │ ├── TrioPlugin.py
│ │ ├── UpxPlugin.py
│ │ ├── __init__.py
│ │ ├── standard.nuitka-package.config.yml
│ │ ├── stdlib2.nuitka-package.config.yml
│ │ └── stdlib3.nuitka-package.config.yml
│ ├── reports/
│ │ ├── CompilationReportReader.py
│ │ ├── LicenseReport.rst.j2
│ │ ├── Reports.py
│ │ └── __init__.py
│ ├── specs/
│ │ ├── BuiltinBytesOperationSpecs.py
│ │ ├── BuiltinDictOperationSpecs.py
│ │ ├── BuiltinListOperationSpecs.py
│ │ ├── BuiltinParameterSpecs.py
│ │ ├── BuiltinStrOperationSpecs.py
│ │ ├── BuiltinTypeOperationSpecs.py
│ │ ├── BuiltinUnicodeOperationSpecs.py
│ │ ├── HardImportSpecs.py
│ │ ├── ParameterSpecs.py
│ │ └── __init__.py
│ ├── tools/
│ │ ├── Basics.py
│ │ ├── __init__.py
│ │ ├── commercial/
│ │ │ └── __init__.py
│ │ ├── data_composer/
│ │ │ ├── DataComposer.py
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── environments/
│ │ │ ├── CreateEnvironment.py
│ │ │ ├── Virtualenv.py
│ │ │ └── __init__.py
│ │ ├── general/
│ │ │ ├── __init__.py
│ │ │ ├── dll_report/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ └── find_module/
│ │ │ ├── FindModuleCode.py
│ │ │ └── __init__.py
│ │ ├── onefile_compressor/
│ │ │ ├── OnefileCompressor.py
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── podman/
│ │ │ ├── Podman.py
│ │ │ ├── __init__.py
│ │ │ ├── __main__.py
│ │ │ └── containers/
│ │ │ ├── CI.containerfile
│ │ │ └── Python-Minor-Versions.containerfile
│ │ ├── profiler/
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── quality/
│ │ │ ├── Git.py
│ │ │ ├── ScanSources.py
│ │ │ ├── __init__.py
│ │ │ ├── apidoc/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── auto_format/
│ │ │ │ ├── AutoFormat.py
│ │ │ │ ├── YamlFormatter.py
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── codespell/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── pylint/
│ │ │ │ ├── PyLint.py
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── restlint/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ └── yamllint/
│ │ │ ├── YamlChecker.py
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── release/
│ │ │ ├── Debian.py
│ │ │ ├── Documentation.py
│ │ │ ├── Release.py
│ │ │ ├── __init__.py
│ │ │ ├── bump/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── debian/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── debian_mentors/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── osc_check/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── osc_upload/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── pypi/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── rpm/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── __main__.py
│ │ │ │ └── nuitka.spec
│ │ │ └── sync_doc/
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ ├── scanning/
│ │ │ ├── DisplayPackageDLLs.py
│ │ │ ├── DisplayPackageData.py
│ │ │ └── __init__.py
│ │ ├── specialize/
│ │ │ ├── CTypeDescriptions.py
│ │ │ ├── Common.py
│ │ │ ├── SpecializeC.py
│ │ │ ├── SpecializePython.py
│ │ │ ├── __init__.py
│ │ │ └── templates_python/
│ │ │ ├── AttributeNodeFixed.py.j2
│ │ │ ├── BuiltinOperationNodeBases.py.j2
│ │ │ ├── ChildrenHavingMixin.py.j2
│ │ │ ├── HardImportCallNode.py.j2
│ │ │ └── HardImportReferenceNode.py.j2
│ │ ├── testing/
│ │ │ ├── Common.py
│ │ │ ├── Constructs.py
│ │ │ ├── OutputComparison.py
│ │ │ ├── Pythons.py
│ │ │ ├── RuntimeTracing.py
│ │ │ ├── SearchModes.py
│ │ │ ├── Valgrind.py
│ │ │ ├── __init__.py
│ │ │ ├── check_reference_counts/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── compare_with_cpython/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── find_sxs_modules/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ ├── measure_construct_performance/
│ │ │ │ ├── __init__.py
│ │ │ │ └── __main__.py
│ │ │ └── run_nuitka_tests/
│ │ │ ├── __init__.py
│ │ │ └── __main__.py
│ │ └── watch/
│ │ ├── GitHub.py
│ │ ├── __init__.py
│ │ └── __main__.py
│ ├── tree/
│ │ ├── Building.py
│ │ ├── ComplexCallHelperFunctions.py
│ │ ├── Extractions.py
│ │ ├── InternalModule.py
│ │ ├── Operations.py
│ │ ├── ReformulationAssertStatements.py
│ │ ├── ReformulationAssignmentStatements.py
│ │ ├── ReformulationBooleanExpressions.py
│ │ ├── ReformulationCallExpressions.py
│ │ ├── ReformulationClasses.py
│ │ ├── ReformulationClasses3.py
│ │ ├── ReformulationComparisonExpressions.py
│ │ ├── ReformulationContractionExpressions.py
│ │ ├── ReformulationDictionaryCreation.py
│ │ ├── ReformulationExecStatements.py
│ │ ├── ReformulationForLoopStatements.py
│ │ ├── ReformulationFunctionStatements.py
│ │ ├── ReformulationImportStatements.py
│ │ ├── ReformulationLambdaExpressions.py
│ │ ├── ReformulationMatchStatements.py
│ │ ├── ReformulationMultidist.py
│ │ ├── ReformulationNamespacePackages.py
│ │ ├── ReformulationPrintStatements.py
│ │ ├── ReformulationSequenceCreation.py
│ │ ├── ReformulationSubscriptExpressions.py
│ │ ├── ReformulationTryExceptStatements.py
│ │ ├── ReformulationTryFinallyStatements.py
│ │ ├── ReformulationWhileLoopStatements.py
│ │ ├── ReformulationWithStatements.py
│ │ ├── ReformulationYieldExpressions.py
│ │ ├── SourceHandling.py
│ │ ├── SyntaxErrors.py
│ │ ├── TreeHelpers.py
│ │ ├── VariableClosure.py
│ │ └── __init__.py
│ └── utils/
│ ├── AppDirs.py
│ ├── CStrings.py
│ ├── CommandLineOptions.py
│ ├── Distributions.py
│ ├── Download.py
│ ├── Execution.py
│ ├── FileOperations.py
│ ├── Hashing.py
│ ├── Images.py
│ ├── Importing.py
│ ├── InstalledPythons.py
│ ├── InstanceCounters.py
│ ├── Jinja2.py
│ ├── Json.py
│ ├── MacOSApp.py
│ ├── MemoryUsage.py
│ ├── ModuleNames.py
│ ├── ReExecute.py
│ ├── Rest.py
│ ├── SharedLibraries.py
│ ├── Shebang.py
│ ├── Signing.py
│ ├── SlotMetaClasses.py
│ ├── StaticLibraries.py
│ ├── ThreadedExecutor.py
│ ├── Timing.py
│ ├── Utils.py
│ ├── WindowsFileUsage.py
│ ├── WindowsResources.py
│ ├── Yaml.py
│ └── __init__.py
├── pyproject.toml
├── requirements-devel.txt
├── requirements.txt
├── rpm/
│ ├── check-osc-status.py
│ ├── make-osc-upload.py
│ ├── nuitka-rpmlintrc
│ └── nuitka.spec
├── setup.py
└── tests/
├── PyPI-pytest/
│ ├── README.rst
│ ├── packages.json
│ └── run_all.py
├── README.txt
├── basics/
│ ├── AssertsTest.py
│ ├── AssignmentsTest.py
│ ├── AssignmentsTest32.py
│ ├── BranchingTest.py
│ ├── BuiltinOverload.py
│ ├── BuiltinSuperTest.py
│ ├── BuiltinsTest.py
│ ├── ClassMinimalTest.py
│ ├── ClassesTest.py
│ ├── ClassesTest32.py
│ ├── ClassesTest34.py
│ ├── ComparisonChainsTest.py
│ ├── ConstantsTest.py
│ ├── ConstantsTest27.py
│ ├── DecoratorsTest.py
│ ├── DefaultParametersTest.py
│ ├── DoubleDeletionsTest.py
│ ├── EmptyModuleTest.py
│ ├── ExceptionRaisingTest.py
│ ├── ExceptionRaisingTest32.py
│ ├── ExceptionRaisingTest33.py
│ ├── ExecEvalTest.py
│ ├── ExtremeClosureTest.py
│ ├── FunctionObjectsTest.py
│ ├── FunctionsTest.py
│ ├── FunctionsTest32.py
│ ├── FunctionsTest_2.py
│ ├── FutureTest32.py
│ ├── GeneratorExpressionsTest.py
│ ├── GeneratorExpressionsTest_37.py
│ ├── GlobalStatementTest.py
│ ├── HelloWorldTest_2.py
│ ├── ImportingTest.py
│ ├── InplaceOperationsTest.py
│ ├── InspectionTest.py
│ ├── InspectionTest_35.py
│ ├── InspectionTest_36.py
│ ├── LambdasTest.py
│ ├── LateClosureAssignmentTest.py
│ ├── ListContractionsTest.py
│ ├── LoopingTest.py
│ ├── MainProgramsTest.py
│ ├── ModuleAttributesTest.py
│ ├── OperatorsTest.py
│ ├── OrderChecksTest.py
│ ├── OrderChecksTest27.py
│ ├── OverflowFunctionsTest_2.py
│ ├── ParameterErrorsTest.py
│ ├── ParameterErrorsTest32.py
│ ├── PrintFutureTest.py
│ ├── PrintingTest_2.py
│ ├── README.rst
│ ├── RecursionTest.py
│ ├── ReferencingTest.py
│ ├── ReferencingTest27.py
│ ├── ReferencingTest33.py
│ ├── ReferencingTest35.py
│ ├── ReferencingTest36.py
│ ├── ReferencingTest_2.py
│ ├── SlotsTest.py
│ ├── ThreadedGeneratorsTest.py
│ ├── TrickAssignmentsTest32.py
│ ├── TrickAssignmentsTest35.py
│ ├── TrickAssignmentsTest_2.py
│ ├── TryContinueFinallyTest.py
│ ├── TryExceptContinueTest.py
│ ├── TryExceptFinallyTest.py
│ ├── TryExceptFramesTest.py
│ ├── TryReturnFinallyTest.py
│ ├── TryYieldFinallyTest.py
│ ├── UnicodeTest.py
│ ├── UnpackingTest35.py
│ ├── VarargsTest.py
│ ├── WithStatementsTest.py
│ ├── YieldFromTest33.py
│ ├── run_all.py
│ └── run_xml.py
├── benchmarks/
│ ├── binary-trees.py
│ ├── comparisons/
│ │ └── GeneratorFunctionVsGeneratorExpression.py
│ ├── constructs/
│ │ ├── BuiltinSumWithGenerator.py
│ │ ├── BuiltinSumWithList.py
│ │ ├── BuiltinSumWithTuple.py
│ │ ├── CallCompiledClassCreationPosArgsConstant6.py
│ │ ├── CallCompiledFunctionKwArgsConstant.py
│ │ ├── CallCompiledFunctionKwArgsVariable.py
│ │ ├── CallCompiledFunctionKwArgsVariableStarDict.py
│ │ ├── CallCompiledFunctionPosArgsConstant.py
│ │ ├── CallCompiledFunctionPosArgsDefaults.py
│ │ ├── CallCompiledFunctionPosArgsMutable.py
│ │ ├── CallCompiledFunctionPosArgsVariable.py
│ │ ├── CallCompiledFunctionPosKwArgsVariable.py
│ │ ├── CallCompiledInstanceMethodNoArgs_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsConstant1_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsConstant6_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsDefaults_27.py
│ │ ├── CallCompiledInstanceMethodPosArgsVariable_27.py
│ │ ├── CallCompiledObjectMethodNoArgs.py
│ │ ├── CallCompiledObjectMethodPosArgsConstant1.py
│ │ ├── CallCompiledObjectMethodPosArgsConstant6.py
│ │ ├── CallCompiledObjectMethodPosArgsDefaults.py
│ │ ├── CallCompiledObjectMethodPosArgsVariable.py
│ │ ├── CallLambdaExpressionDirectly.py
│ │ ├── CallUncompiledFunctionComplexArgs.py
│ │ ├── CallUncompiledFunctionPosArgs.py
│ │ ├── ClosureVariableAccess.py
│ │ ├── DictCreation.py
│ │ ├── FunctionCreationClosure.py
│ │ ├── FunctionCreationGeneratorClosure.py
│ │ ├── FunctionCreationGeneratorLocal.py
│ │ ├── FunctionCreationLocal.py
│ │ ├── FunctionEmpty.py
│ │ ├── FunctionRaise.py
│ │ ├── GeneratorExit.py
│ │ ├── GeneratorExpressionCreation.py
│ │ ├── GeneratorExpressionExit.py
│ │ ├── GeneratorExpressionUsage.py
│ │ ├── GeneratorUsage.py
│ │ ├── GlobalVariableAccess.py
│ │ ├── InplaceOperationFloatAdd.py
│ │ ├── InplaceOperationInstanceStringAdd.py
│ │ ├── InplaceOperationIntegerAdd.py
│ │ ├── InplaceOperationIntegerMul.py
│ │ ├── InplaceOperationListAdd.py
│ │ ├── InplaceOperationLongAdd_27.py
│ │ ├── InplaceOperationStringAdd.py
│ │ ├── InplaceOperationTupleAdd.py
│ │ ├── InplaceOperationUnicodeAdd_27.py
│ │ ├── ListContraction.py
│ │ ├── ListCreation.py
│ │ ├── ListCreationConstant.py
│ │ ├── LocalVariableAccess.py
│ │ ├── LocalVariableDeletion.py
│ │ ├── LoopSmallRange.py
│ │ ├── LoopSmallXrange.py
│ │ ├── NumpyArrayConstruction.py
│ │ ├── OperationAttributeLookup.py
│ │ ├── OperationFloatAdd.py
│ │ ├── OperationIntegerAdd.py
│ │ ├── OperationIntegerMul.py
│ │ ├── OperationIntegerPower.py
│ │ ├── OperationListIntegerIndexLookup.py
│ │ ├── RichComparisonConditionStrings.py
│ │ ├── RichComparisonStrings.py
│ │ ├── SetCreation.py
│ │ ├── TupleCreation.py
│ │ └── UnpackIterator.py
│ ├── mandelbrot.py
│ ├── pybench/
│ │ ├── Arithmetic.py
│ │ ├── Calls.py
│ │ ├── CommandLine.py
│ │ ├── Constructs.py
│ │ ├── Dict.py
│ │ ├── Exceptions.py
│ │ ├── Imports.py
│ │ ├── Instances.py
│ │ ├── LICENSE
│ │ ├── Lists.py
│ │ ├── Lookups.py
│ │ ├── NewInstances.py
│ │ ├── Numbers.py
│ │ ├── README
│ │ ├── Setup.py
│ │ ├── Strings.py
│ │ ├── Tuples.py
│ │ ├── Unicode.py
│ │ ├── With.py
│ │ ├── clockres.py
│ │ ├── package/
│ │ │ ├── __init__.py
│ │ │ └── submodule.py
│ │ ├── pybench.py
│ │ └── systimes.py
│ ├── pystone.py
│ ├── pystone3.py
│ └── recipe-577834-1.py
├── codegen-analysis/
│ └── README.txt
├── distutils/
│ ├── .gitignore
│ ├── example_1_pyproject/
│ │ ├── data_files/
│ │ │ └── some_datafile.txt
│ │ ├── example1_package/
│ │ │ ├── __init__.py
│ │ │ └── data/
│ │ │ └── package_data.txt
│ │ ├── pyproject.cpython.toml
│ │ ├── pyproject.nuitka.toml
│ │ ├── runner
│ │ └── setup.cfg
│ ├── example_1_setuptools/
│ │ ├── data_files/
│ │ │ └── some_datafile.txt
│ │ ├── example1_package/
│ │ │ ├── __init__.py
│ │ │ └── data/
│ │ │ └── package_data.txt
│ │ ├── runner
│ │ └── setup.py
│ ├── example_2_pyproject/
│ │ ├── pyproject.cpython.toml
│ │ ├── pyproject.nuitka.toml
│ │ └── src/
│ │ └── main.py
│ ├── example_2_setuptools/
│ │ ├── package1/
│ │ │ ├── __init__.py
│ │ │ ├── main.py
│ │ │ ├── module1.py
│ │ │ ├── module2.py
│ │ │ ├── subpackage1/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── data.txt
│ │ │ │ └── submodule11.py
│ │ │ └── subpackage2/
│ │ │ ├── __init__.py
│ │ │ └── submodule21.py
│ │ └── setup.py
│ ├── example_3_pyproject/
│ │ ├── pyproject.cpython.toml
│ │ ├── pyproject.nuitka.toml
│ │ └── src/
│ │ ├── runner
│ │ └── some_namespace/
│ │ └── some_package/
│ │ ├── __init__.py
│ │ └── sub_package/
│ │ └── __init__.py
│ ├── example_3_setuptools32/
│ │ ├── outer/
│ │ │ └── inner/
│ │ │ ├── __init__.py
│ │ │ └── main.py
│ │ └── setup.py
│ ├── example_4_setuptools_cfg/
│ │ ├── data_files/
│ │ │ └── some_datafile.txt
│ │ ├── example1_package/
│ │ │ ├── __init__.py
│ │ │ └── data/
│ │ │ └── package_data.txt
│ │ ├── runner
│ │ ├── setup.cfg
│ │ └── setup.py
│ ├── example_5_versioneer_setuptools32/
│ │ ├── runner
│ │ ├── setup.cfg
│ │ ├── setup.py
│ │ ├── some_package/
│ │ │ ├── __init__.py
│ │ │ └── _version.py
│ │ └── versioneer.py
│ ├── example_multiple_packages/
│ │ ├── main_module.py
│ │ ├── other_package/
│ │ │ └── __init__.py
│ │ ├── other_package_a/
│ │ │ └── __init__.py
│ │ ├── runner
│ │ ├── setup.py
│ │ ├── some_package/
│ │ │ └── __init__.py
│ │ ├── some_package_a/
│ │ │ └── __init__.py
│ │ └── some_package_b/
│ │ └── __init__.py
│ ├── example_nested_namespaces32/
│ │ ├── a/
│ │ │ └── b/
│ │ │ └── pkg/
│ │ │ └── __init__.py
│ │ └── setup.py
│ ├── example_package_and_module/
│ │ ├── runner
│ │ ├── setup.py
│ │ ├── some_module.py
│ │ └── some_package/
│ │ └── __init__.py
│ ├── example_pymodules_only/
│ │ ├── py_modules_only.py
│ │ ├── runner
│ │ └── setup.py
│ └── run_all.py
├── generated/
│ ├── BigConstantsTest.py.j2
│ ├── BytesMethodsTest.py.j2
│ ├── BytesMethodsTest32.py.j2
│ ├── DictMethodsTest.py.j2
│ ├── InplaceTest.py.j2
│ ├── OperationsTest.py.j2
│ ├── StrMethodsTest.py.j2
│ └── run_all.py
├── library/
│ ├── check_yaml_anti_bloat_modules.py
│ ├── compile_extension_modules.py
│ └── compile_python_modules.py
├── onefile/
│ ├── HelloWorldTest.py
│ ├── KeyboardInterruptTest.py
│ └── run_all.py
├── optimizations/
│ ├── ArgumentTypes.py
│ ├── AttributesTest.py
│ ├── CallsTest.py
│ ├── ConditionsTest.py
│ ├── DecodingOperationsTest.py
│ ├── FormatStringsTest36.py
│ ├── HardImportsTest.py
│ ├── HardImportsTest_2.py
│ ├── Iterations.py
│ ├── LenTest.py
│ ├── MatchingTest310.py
│ ├── OperationsTest.py
│ ├── SubscriptsTest.py
│ └── run_all.py
├── packages/
│ ├── package_data_files_embedding/
│ │ ├── PackageDataFilesEmbedding.py
│ │ ├── __init__.py
│ │ ├── lala.txt
│ │ └── sub_dir/
│ │ └── lulu.txt
│ ├── package_import_success_after_failure/
│ │ ├── PackageImportSuccessAfterFailure.py
│ │ └── variable_package/
│ │ ├── SomeModule.py
│ │ └── __init__.py
│ ├── run_all.py
│ ├── sub_package/
│ │ └── kitty/
│ │ ├── __init__.py
│ │ ├── bigkitty.py
│ │ ├── smallkitty.py
│ │ └── speak/
│ │ ├── __init__.py
│ │ ├── hello.py
│ │ ├── miau.py
│ │ └── purr.py
│ └── top_level_attributes_3/
│ └── some_package/
│ ├── __init__.py
│ └── some_module.py
├── pgo/
│ ├── run_all.py
│ └── unused_module/
│ ├── ImportedButMaybeNotUsed.py
│ └── UnusedModuleMain.py
├── plugins/
│ ├── README.rst
│ ├── code_signing/
│ │ └── CodeSigningMain.py
│ ├── data_files/
│ │ ├── DataFilesMain.py
│ │ ├── data_files_package/
│ │ │ ├── __init__.py
│ │ │ ├── lala.txt
│ │ │ └── sub_dir/
│ │ │ └── lulu.txt
│ │ └── test_case.nuitka-package.config.yml
│ ├── parameters/
│ │ ├── ParametersMain.py
│ │ └── parameter-using-plugin.py
│ └── run_all.py
├── programs/
│ ├── absolute_import/
│ │ ├── AbsoluteImportMain.py
│ │ └── foobar/
│ │ ├── __init__.py
│ │ ├── foobar.py
│ │ ├── local.py
│ │ └── util.py
│ ├── case_imports1/
│ │ ├── CasedImportingMain.py
│ │ ├── path1/
│ │ │ ├── Some_Module.py
│ │ │ └── Some_Package/
│ │ │ └── __init__.py
│ │ └── path2/
│ │ ├── some_module.py
│ │ └── some_package/
│ │ └── __init__.py
│ ├── case_imports2/
│ │ ├── CasedImportingMain.py
│ │ ├── path1/
│ │ │ ├── some_module.py
│ │ │ └── some_package/
│ │ │ └── __init__.py
│ │ └── path2/
│ │ ├── Some_Module.py
│ │ └── Some_Package/
│ │ └── __init__.py
│ ├── case_imports3/
│ │ ├── CasedImportingMain.py
│ │ ├── path1/
│ │ │ ├── Some_Module.py
│ │ │ └── Some_Package/
│ │ │ └── __init__.py
│ │ └── path2/
│ │ ├── Some_Module.py
│ │ └── Some_Package/
│ │ └── __init__.py
│ ├── cyclic_imports/
│ │ ├── CyclicImportsMain.py
│ │ └── cyclic_importing_package/
│ │ ├── Child1.py
│ │ ├── Child2.py
│ │ └── __init__.py
│ ├── dash_import/
│ │ ├── DashImportMain.py
│ │ ├── dash-module.py
│ │ └── plus+module.py
│ ├── dash_main/
│ │ └── Dash-Main.py
│ ├── deep/
│ │ ├── DeepProgramMain.py
│ │ └── some_package/
│ │ ├── DeepBrother.py
│ │ ├── DeepChild.py
│ │ ├── __init__.py
│ │ └── deep_package/
│ │ ├── DeepDeepChild.py
│ │ └── __init__.py
│ ├── dunderinit_imports/
│ │ ├── DunderInitImportsMain.py
│ │ └── package/
│ │ ├── SubModule.py
│ │ └── __init__.py
│ ├── import_variants/
│ │ ├── ImportVariationsMain.py
│ │ └── some_package/
│ │ ├── Child1.py
│ │ ├── Child2.py
│ │ ├── Child3.py
│ │ └── __init__.py
│ ├── main_raises/
│ │ ├── ErrorMain.py
│ │ └── ErrorRaising.py
│ ├── main_raises2/
│ │ ├── ErrorInFunctionMain.py
│ │ └── ErrorRaising.py
│ ├── module_attributes/
│ │ ├── ModuleAttributesMain.py
│ │ └── package_level1/
│ │ ├── Nearby1.py
│ │ ├── __init__.py
│ │ └── package_level2/
│ │ ├── Nearby2.py
│ │ ├── __init__.py
│ │ └── package_level3/
│ │ ├── Nearby3.py
│ │ └── __init__.py
│ ├── module_exits/
│ │ ├── ErrorExitingModule.py
│ │ └── Main.py
│ ├── module_object_replacing/
│ │ ├── ModuleObjectReplacingMain.py
│ │ └── SelfReplacingModule.py
│ ├── multiprocessing_using/
│ │ ├── MultiprocessingUsingMain.py
│ │ └── foo/
│ │ ├── __init__.py
│ │ ├── __main__.py
│ │ └── entry.py
│ ├── named_imports/
│ │ ├── NamedImportsMain.py
│ │ └── some_package/
│ │ ├── SomeModule.py
│ │ ├── __init__.py
│ │ └── sub_package/
│ │ └── SomeModule.py
│ ├── package_code/
│ │ ├── PackageInitCodeMain.py
│ │ └── some_package/
│ │ ├── SomeModule.py
│ │ └── __init__.py
│ ├── package_contains_main/
│ │ ├── PackageContainsMain.py
│ │ ├── __init__.py
│ │ └── local.py
│ ├── package_init_import/
│ │ ├── PackageInitImportMain.py
│ │ └── some_package/
│ │ ├── PackageLocal.py
│ │ └── __init__.py
│ ├── package_init_issue/
│ │ ├── PackageInitIssueMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ └── child_package/
│ │ ├── SomeModule.py
│ │ └── __init__.py
│ ├── package_missing_init/
│ │ ├── PackageMissingInitMain.py
│ │ └── some_package/
│ │ ├── some_module.py
│ │ └── sub_package/
│ │ └── some_sub_module.py
│ ├── package_module_collision/
│ │ ├── PackageAndModuleNamedSameMain.py
│ │ ├── Something/
│ │ │ └── __init__.py
│ │ └── something.py
│ ├── package_overload/
│ │ ├── Main.py
│ │ └── foo/
│ │ ├── __init__.py
│ │ ├── bar.py
│ │ └── bar2.py
│ ├── package_prevents_submodule/
│ │ ├── PackagePreventsSubmoduleMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ └── some_module.py
│ ├── package_program/
│ │ └── PackageAsMain/
│ │ ├── __init__.py
│ │ └── __main__.py
│ ├── pkgutil_itermodules/
│ │ ├── PkgUtilIterModulesMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ ├── sub_package1/
│ │ │ ├── SomeModuleC.py
│ │ │ ├── SomeModuleD.py
│ │ │ └── __init__.py
│ │ └── sub_package2/
│ │ ├── SomeModuleA.py
│ │ ├── SomeModuleB.py
│ │ └── __init__.py
│ ├── pkgutil_usage/
│ │ ├── PkgUtilUsageMain.py
│ │ └── package/
│ │ ├── DATA_FILE.txt
│ │ ├── DATA_FILE2.txt
│ │ ├── DATA_FILE3.txt
│ │ └── __init__.py
│ ├── plugin_import/
│ │ ├── PluginImportMain.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ ├── data/
│ │ │ └── .gitignore
│ │ └── some_module.py
│ ├── reimport_main_dynamic/
│ │ └── ImportItselfDynamicMain.py
│ ├── reimport_main_static/
│ │ └── ImportItselfStaticMain.py
│ ├── relative_import/
│ │ ├── RelativeImportMain.py
│ │ └── dircache.py
│ ├── resource_reader37/
│ │ ├── ResourceReaderMain.py
│ │ └── some_package/
│ │ ├── DATA_FILE.txt
│ │ └── __init__.py
│ ├── run_all.py
│ ├── stdlib_overload/
│ │ ├── StdlibOverloadMain.py
│ │ ├── pyexpat.py
│ │ └── some_package/
│ │ ├── __init__.py
│ │ ├── normal_importing.py
│ │ ├── pyexpat.py
│ │ └── star_importing.py
│ ├── syntax_errors/
│ │ ├── IndentationErroring.py
│ │ ├── SyntaxErroring.py
│ │ └── SyntaxErrorsMain.py
│ ├── unicode_bom/
│ │ ├── UnicodeBomMain.py
│ │ └── unicode_bom.py
│ └── with space/
│ └── Space Main.py
├── reflected/
│ └── compile_itself.py
├── run-tests
├── standalone/
│ ├── BrotliUsing.py
│ ├── CtypesUsing.py
│ ├── DateutilsUsing.py
│ ├── FlaskUsing.py
│ ├── GiUsing.py
│ ├── GlfwUsing.py
│ ├── GtkUsing.py
│ ├── HexEncodingTest_2.py
│ ├── IdnaUsing.py
│ ├── LxmlUsing.py
│ ├── MatplotlibUsing.py
│ ├── MetadataPackagesUsing.py
│ ├── NumpyUsing.py
│ ├── OpenGLUsing.py
│ ├── PandasUsing.py
│ ├── PasslibUsing.py
│ ├── PendulumUsing.py
│ ├── PkgResourcesRequiresUsing.py
│ ├── PmwUsing.py
│ ├── PyQt5Plugins.py
│ ├── PyQt5SSLSupport.py
│ ├── PyQt5Using.py
│ ├── PyQt6Plugins.py
│ ├── PyQt6Using.py
│ ├── PySide2Using.py
│ ├── PySide6Plugins.py
│ ├── PySide6Using.py
│ ├── RsaUsing.py
│ ├── SetuptoolsUsing.py
│ ├── ShlibUsing.py
│ ├── SocketUsing.py
│ ├── TkInterUsing.py
│ ├── Urllib3Using.py
│ ├── Win32ComUsing.py
│ ├── run_all.py
│ └── zip_importer/
│ └── ZipImporterMain.py
├── syntax/
│ ├── AsyncgenReturn36.py
│ ├── AwaitInModule36.py
│ ├── BreakWithoutLoop.py
│ ├── ClassReturn.py
│ ├── ClosureDel_2.py
│ ├── ContinueWithoutLoop.py
│ ├── DuplicateArgument.py
│ ├── ExecWithNesting_2.py
│ ├── FutureBraces.py
│ ├── FutureUnknown.py
│ ├── GeneratorExpressions38.py
│ ├── GeneratorReturn_2.py
│ ├── GlobalForParameter.py
│ ├── Importing32.py
│ ├── IndentationError.py
│ ├── LateFutureImport.py
│ ├── MisplacedFutureImport.py
│ ├── ModuleReturn.py
│ ├── NonAsciiWithoutEncoding_2.py
│ ├── NonlocalForParameter32.py
│ ├── NonlocalNotFound32.py
│ ├── StarImportExtra.py
│ ├── SyntaxError.py
│ ├── TryExceptAllNotLast.py
│ ├── TryFinallyContinue_37.py
│ ├── UnpackNoTuple.py
│ ├── UnpackTwoStars32.py
│ ├── YieldFromInModule.py
│ ├── YieldInAsync35.py
│ ├── YieldInGenexp38.py
│ ├── YieldInModule.py
│ └── run_all.py
├── test-runners/
│ ├── run_all.py
│ └── subject/
│ └── package/
│ ├── Something.py
│ ├── __init__.py
│ ├── sub_package1/
│ │ ├── SubSomething1.py
│ │ ├── __init__.py
│ │ └── tests/
│ │ ├── __init__.py
│ │ └── test_subsomething1.py
│ ├── sub_package2/
│ │ ├── SubSomething2.py
│ │ ├── __init__.py
│ │ └── tests/
│ │ ├── __init__.py
│ │ └── test_subsomething2.py
│ └── tests/
│ ├── __init__.py
│ └── test_something.py
└── type_inference/
├── Test1.py
├── Test2.py
├── Test3.py
└── Test4.py
Showing preview only (2,387K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (27961 symbols across 1354 files)
FILE: lib/hints.py
function _normalizePath (line 27) | def _normalizePath(path):
function _moduleRepr (line 54) | def _moduleRepr(module):
function _ourimport (line 76) | def _ourimport(
function enableImportTracing (line 137) | def enableImportTracing(normalize_paths=True, show_source=False):
FILE: misc/install-git-hooks.py
function main (line 29) | def main():
FILE: misc/make-coverage-rendering.py
function main (line 11) | def main():
FILE: nuitka/Builtins.py
function _getBuiltinExceptionNames (line 16) | def _getBuiltinExceptionNames():
function _getBuiltinNames (line 74) | def _getBuiltinNames():
function getBuiltinTypeNames (line 120) | def getBuiltinTypeNames():
function _getAnonBuiltins (line 133) | def _getAnonBuiltins():
FILE: nuitka/BytecodeCaching.py
function getBytecodeCacheDir (line 24) | def getBytecodeCacheDir():
function _getCacheFilename (line 28) | def _getCacheFilename(module_name, extension):
function makeCacheName (line 32) | def makeCacheName(module_name, source_code):
function hasCachedImportedModuleUsageAttempts (line 44) | def hasCachedImportedModuleUsageAttempts(module_name, source_code, sourc...
function getCachedImportedModuleUsageAttempts (line 56) | def getCachedImportedModuleUsageAttempts(module_name, source_code, sourc...
function writeImportedModulesNamesToCache (line 124) | def writeImportedModulesNamesToCache(
function _getModuleConfigHash (line 147) | def _getModuleConfigHash(full_name):
FILE: nuitka/Bytecodes.py
function _removeDocFromBody (line 18) | def _removeDocFromBody(node):
function compileSourceToBytecode (line 26) | def compileSourceToBytecode(source_code, filename):
function loadCodeObjectData (line 85) | def loadCodeObjectData(bytecode_filename):
FILE: nuitka/CacheCleanup.py
function _cleanCacheDirectory (line 18) | def _cleanCacheDirectory(cache_name, cache_dir):
function cleanCaches (line 29) | def cleanCaches():
FILE: nuitka/Constants.py
function compareConstants (line 29) | def compareConstants(a, b):
function isConstant (line 123) | def isConstant(constant):
function isMutable (line 193) | def isMutable(constant):
function isHashable (line 242) | def isHashable(constant):
function getUnhashableConstant (line 281) | def getUnhashableConstant(constant):
function createConstantDict (line 317) | def createConstantDict(keys, values):
function isCompileTimeConstantValue (line 327) | def isCompileTimeConstantValue(value):
function getConstantValueGuide (line 351) | def getConstantValueGuide(constant, elements_only):
FILE: nuitka/Errors.py
class NuitkaErrorBase (line 12) | class NuitkaErrorBase(Exception):
class NuitkaNodeError (line 16) | class NuitkaNodeError(NuitkaErrorBase):
method __str__ (line 18) | def __str__(self):
class NuitkaOptimizationError (line 38) | class NuitkaOptimizationError(NuitkaNodeError):
class NuitkaAssumptionError (line 42) | class NuitkaAssumptionError(AssertionError):
class NuitkaCodeDeficit (line 46) | class NuitkaCodeDeficit(NuitkaErrorBase):
class NuitkaNodeDesignError (line 50) | class NuitkaNodeDesignError(Exception):
class NuitkaForbiddenImportEncounter (line 54) | class NuitkaForbiddenImportEncounter(Exception):
class CodeTooComplexCode (line 58) | class CodeTooComplexCode(Exception):
class NuitkaForbiddenDLLEncounter (line 68) | class NuitkaForbiddenDLLEncounter(Exception):
FILE: nuitka/HardImportRegistry.py
function isHardModule (line 91) | def isHardModule(module_name):
function isHardModuleWithoutSideEffect (line 119) | def isHardModuleWithoutSideEffect(module_name):
function _addHardImportNodeClasses (line 272) | def _addHardImportNodeClasses():
function _checkHardModules (line 294) | def _checkHardModules():
function addModuleTrust (line 317) | def addModuleTrust(module_name, attribute_name, trust_value):
function addModuleSingleAttributeNodeFactory (line 321) | def addModuleSingleAttributeNodeFactory(module_name, attribute_name, nod...
function addModuleAttributeFactory (line 326) | def addModuleAttributeFactory(module_name, attribute_name, node_class):
function addModuleDynamicHard (line 330) | def addModuleDynamicHard(module_name):
function isHardModuleDynamic (line 339) | def isHardModuleDynamic(module_name):
FILE: nuitka/MainControl.py
function _createMainModule (line 121) | def _createMainModule():
function dumpTreeXML (line 278) | def dumpTreeXML():
function pickSourceFilenames (line 290) | def pickSourceFilenames(source_dir, modules):
function makeSourceDirectory (line 362) | def makeSourceDirectory():
function _runPgoBinary (line 471) | def _runPgoBinary():
function _wasMsvcMode (line 483) | def _wasMsvcMode():
function _deleteMsvcPGOFiles (line 495) | def _deleteMsvcPGOFiles(pgo_mode):
function _runCPgoBinary (line 508) | def _runCPgoBinary():
function _runPythonPgoBinary (line 547) | def _runPythonPgoBinary():
function runSconsBackend (line 566) | def runSconsBackend():
function callExecPython (line 762) | def callExecPython(args, add_path):
function _executeMain (line 775) | def _executeMain(binary_filename):
function _executeModule (line 785) | def _executeModule(tree):
function compileTree (line 830) | def compileTree():
function handleSyntaxError (line 900) | def handleSyntaxError(e):
function _main (line 924) | def _main():
function main (line 1122) | def main():
FILE: nuitka/ModuleRegistry.py
function addRootModule (line 37) | def addRootModule(module):
function getRootModules (line 41) | def getRootModules():
function getRootTopModule (line 45) | def getRootTopModule():
function hasRootModule (line 53) | def hasRootModule(module_name):
function replaceRootModule (line 61) | def replaceRootModule(old, new):
function getUncompiledModules (line 75) | def getUncompiledModules():
function getUncompiledTechnicalModules (line 85) | def getUncompiledTechnicalModules():
function getUncompiledNonTechnicalModules (line 95) | def getUncompiledNonTechnicalModules():
function _normalizeModuleFilename (line 105) | def _normalizeModuleFilename(filename):
function startTraversal (line 123) | def startTraversal():
function addUsedModule (line 144) | def addUsedModule(module, using_module, usage_tag, reason, source_ref):
function nextModule (line 158) | def nextModule():
function getRemainingModulesCount (line 168) | def getRemainingModulesCount():
function getDoneModulesCount (line 172) | def getDoneModulesCount():
function getDoneModules (line 176) | def getDoneModules():
function hasDoneModule (line 180) | def hasDoneModule(module_name):
function getModuleInclusionInfoByName (line 184) | def getModuleInclusionInfoByName(module_name):
function getModuleFromCodeName (line 192) | def getModuleFromCodeName(code_name):
function getOwnerFromCodeName (line 201) | def getOwnerFromCodeName(code_name):
function getModuleByName (line 211) | def getModuleByName(module_name):
function addModuleInfluencingCondition (line 226) | def addModuleInfluencingCondition(
function addModuleInfluencingVariable (line 236) | def addModuleInfluencingVariable(
function addModuleInfluencingParameter (line 250) | def addModuleInfluencingParameter(
function addModuleInfluencingDetection (line 264) | def addModuleInfluencingDetection(
function getModuleInfluences (line 274) | def getModuleInfluences(module_name):
function addModuleOptimizationTimeInformation (line 286) | def addModuleOptimizationTimeInformation(module_name, pass_number, time_...
function getModuleOptimizationTimingInfos (line 294) | def getModuleOptimizationTimingInfos(module_name):
FILE: nuitka/OptionParsing.py
function _considerPluginOptions (line 1718) | def _considerPluginOptions(logger):
class _RetainingFormatter (line 1771) | class _RetainingFormatter(Formatter):
method get_value (line 1772) | def get_value(self, key, args, kwargs):
function _expandProjectArg (line 1782) | def _expandProjectArg(arg, filename_arg, for_eval):
function getNuitkaProjectOptions (line 1822) | def getNuitkaProjectOptions(logger, filename_arg, module_mode):
function _considerGithubWorkflowOptions (line 1931) | def _considerGithubWorkflowOptions(phase):
function parseOptions (line 2008) | def parseOptions(logger):
function runSpecialCommandsFromOptions (line 2093) | def runSpecialCommandsFromOptions(options):
FILE: nuitka/Options.py
function _convertOldStylePathSpecQuotes (line 91) | def _convertOldStylePathSpecQuotes(value):
function checkPathSpec (line 109) | def checkPathSpec(value, arg_name, allow_disable):
function _checkOnefileTargetSpec (line 227) | def _checkOnefileTargetSpec():
function _getVersionInformationValues (line 269) | def _getVersionInformationValues():
function printVersionInformation (line 299) | def printVersionInformation():
function _warnOnefileOnlyOption (line 318) | def _warnOnefileOnlyOption(option_name):
function parseArgs (line 328) | def parseArgs():
function commentArgs (line 858) | def commentArgs():
function isVerbose (line 1155) | def isVerbose():
function shallTraceExecution (line 1160) | def shallTraceExecution():
function shallExecuteImmediately (line 1165) | def shallExecuteImmediately():
function shallRunInDebugger (line 1170) | def shallRunInDebugger():
function getXMLDumpOutputFilename (line 1175) | def getXMLDumpOutputFilename():
function shallOnlyExecCCompilerCall (line 1180) | def shallOnlyExecCCompilerCall():
function shallNotDoExecCCompilerCall (line 1185) | def shallNotDoExecCCompilerCall():
function getFileReferenceMode (line 1190) | def getFileReferenceMode():
function getModuleNameMode (line 1201) | def getModuleNameMode():
function shallMakeModule (line 1211) | def shallMakeModule():
function shallCreatePyiFile (line 1216) | def shallCreatePyiFile():
function isAllowedToReexecute (line 1221) | def isAllowedToReexecute():
function shallFollowStandardLibrary (line 1226) | def shallFollowStandardLibrary():
function shallFollowNoImports (line 1231) | def shallFollowNoImports():
function shallFollowAllImports (line 1236) | def shallFollowAllImports():
function _splitShellPattern (line 1241) | def _splitShellPattern(value):
function getShallFollowInNoCase (line 1245) | def getShallFollowInNoCase():
function getShallFollowModules (line 1250) | def getShallFollowModules():
function getShallFollowExtra (line 1263) | def getShallFollowExtra():
function getShallFollowExtraFilePatterns (line 1268) | def getShallFollowExtraFilePatterns():
function getMustIncludeModules (line 1273) | def getMustIncludeModules():
function getMustIncludePackages (line 1278) | def getMustIncludePackages():
function getShallIncludeDistributionMetadata (line 1283) | def getShallIncludeDistributionMetadata():
function getShallIncludePackageData (line 1290) | def getShallIncludePackageData():
function getShallIncludeDataFiles (line 1309) | def getShallIncludeDataFiles():
function getShallIncludeDataDirs (line 1328) | def getShallIncludeDataDirs():
function getShallNotIncludeDataFilePatterns (line 1336) | def getShallNotIncludeDataFilePatterns():
function getShallIncludeExternallyDataFilePatterns (line 1342) | def getShallIncludeExternallyDataFilePatterns():
function getShallNotIncludeDllFilePatterns (line 1348) | def getShallNotIncludeDllFilePatterns():
function shallWarnImplicitRaises (line 1354) | def shallWarnImplicitRaises():
function shallWarnUnusualCode (line 1359) | def shallWarnUnusualCode():
function assumeYesForDownloads (line 1364) | def assumeYesForDownloads():
function _isDebug (line 1369) | def _isDebug():
function shallUsePythonDebug (line 1374) | def shallUsePythonDebug():
function isUnstripped (line 1386) | def isUnstripped():
function isProfile (line 1399) | def isProfile():
function shallCreateGraph (line 1404) | def shallCreateGraph():
function getOutputFilename (line 1409) | def getOutputFilename():
function getOutputPath (line 1414) | def getOutputPath(path):
function getOutputDir (line 1422) | def getOutputDir():
function getPositionalArgs (line 1427) | def getPositionalArgs():
function getMainArgs (line 1432) | def getMainArgs():
function getMainEntryPointFilenames (line 1437) | def getMainEntryPointFilenames():
function shallOptimizeStringExec (line 1450) | def shallOptimizeStringExec():
function _shallUseStaticLibPython (line 1458) | def _shallUseStaticLibPython():
function shallUseStaticLibPython (line 1519) | def shallUseStaticLibPython():
function shallTreatUninstalledPython (line 1545) | def shallTreatUninstalledPython():
function shallCreateCmdFileForExecution (line 1565) | def shallCreateCmdFileForExecution():
function isShowScons (line 1574) | def isShowScons():
function getJobLimit (line 1579) | def getJobLimit():
function getLtoMode (line 1595) | def getLtoMode():
function isClang (line 1600) | def isClang():
function isMingw64 (line 1612) | def isMingw64():
function getMsvcVersion (line 1620) | def getMsvcVersion():
function shallCleanCache (line 1628) | def shallCleanCache(cache_name):
function shallDisableCacheUsage (line 1637) | def shallDisableCacheUsage(cache_name):
function shallDisableCCacheUsage (line 1645) | def shallDisableCCacheUsage():
function shallDisableBytecodeCacheUsage (line 1650) | def shallDisableBytecodeCacheUsage():
function shallDisableCompressionCacheUsage (line 1655) | def shallDisableCompressionCacheUsage():
function shallDisableConsoleWindow (line 1660) | def shallDisableConsoleWindow():
function mayDisableConsoleWindow (line 1665) | def mayDisableConsoleWindow():
function _isFullCompat (line 1672) | def _isFullCompat():
function isShowProgress (line 1682) | def isShowProgress():
function isShowMemory (line 1687) | def isShowMemory():
function isShowInclusion (line 1692) | def isShowInclusion():
function isRemoveBuildDir (line 1697) | def isRemoveBuildDir():
function isDeploymentMode (line 1702) | def isDeploymentMode():
function getNoDeploymentIndications (line 1707) | def getNoDeploymentIndications():
function isExperimental (line 1715) | def isExperimental(indication):
function enableExperimental (line 1726) | def enableExperimental(indication):
function getExperimentalIndications (line 1730) | def getExperimentalIndications():
function shallExplainImports (line 1738) | def shallExplainImports():
function isStandaloneMode (line 1743) | def isStandaloneMode():
function isOnefileMode (line 1748) | def isOnefileMode():
function isAcceleratedMode (line 1753) | def isAcceleratedMode():
function isOnefileTempDirMode (line 1758) | def isOnefileTempDirMode():
function isPgoMode (line 1779) | def isPgoMode():
function isPythonPgoMode (line 1784) | def isPythonPgoMode():
function getPythonPgoInput (line 1789) | def getPythonPgoInput():
function shallCreatePgoInput (line 1794) | def shallCreatePgoInput():
function getPgoArgs (line 1798) | def getPgoArgs():
function getPgoExecutable (line 1803) | def getPgoExecutable():
function getPythonPgoUnseenModulePolicy (line 1813) | def getPythonPgoUnseenModulePolicy():
function getOnefileTempDirSpec (line 1818) | def getOnefileTempDirSpec():
function getOnefileChildGraceTime (line 1828) | def getOnefileChildGraceTime():
function shallNotCompressOnefile (line 1837) | def shallNotCompressOnefile():
function shallOnefileAsArchive (line 1842) | def shallOnefileAsArchive():
function _checkIconPaths (line 1847) | def _checkIconPaths(icon_paths):
function getWindowsIconPaths (line 1859) | def getWindowsIconPaths():
function getLinuxIconPaths (line 1864) | def getLinuxIconPaths():
function getMacOSIconPaths (line 1885) | def getMacOSIconPaths():
function getWindowsIconExecutablePath (line 1890) | def getWindowsIconExecutablePath():
function shallAskForWindowsAdminRights (line 1895) | def shallAskForWindowsAdminRights():
function shallAskForWindowsUIAccessRights (line 1900) | def shallAskForWindowsUIAccessRights():
function getLegalCopyright (line 1905) | def getLegalCopyright():
function getLegalTrademarks (line 1910) | def getLegalTrademarks():
function getLegalInformation (line 1915) | def getLegalInformation():
function getWindowsVersionInfoStrings (line 1927) | def getWindowsVersionInfoStrings():
function _parseVersionNumber (line 1952) | def _parseVersionNumber(value):
function getProductVersion (line 1969) | def getProductVersion():
function getProductVersionTuple (line 1974) | def getProductVersionTuple():
function getFileVersion (line 1979) | def getFileVersion():
function getFileVersionTuple (line 1984) | def getFileVersionTuple():
function getWindowsSplashScreen (line 1989) | def getWindowsSplashScreen():
function getCompanyName (line 1994) | def getCompanyName():
function getProductName (line 1999) | def getProductName():
function getMacOSTargetArch (line 2004) | def getMacOSTargetArch():
function shallCreateAppBundle (line 2014) | def shallCreateAppBundle():
function getMacOSSigningIdentity (line 2019) | def getMacOSSigningIdentity():
function shallUseSigningForNotarization (line 2029) | def shallUseSigningForNotarization():
function getMacOSAppName (line 2034) | def getMacOSAppName():
function getMacOSSignedAppName (line 2039) | def getMacOSSignedAppName():
function getMacOSAppVersion (line 2044) | def getMacOSAppVersion():
function getMacOSAppProtectedResourcesAccesses (line 2049) | def getMacOSAppProtectedResourcesAccesses():
function isMacOSBackgroundApp (line 2055) | def isMacOSBackgroundApp():
function isMacOSUiElementApp (line 2060) | def isMacOSUiElementApp():
function _getPythonFlags (line 2068) | def _getPythonFlags():
function hasPythonFlagNoSite (line 2119) | def hasPythonFlagNoSite():
function hasPythonFlagNoAnnotations (line 2125) | def hasPythonFlagNoAnnotations():
function hasPythonFlagNoAsserts (line 2131) | def hasPythonFlagNoAsserts():
function hasPythonFlagNoDocStrings (line 2137) | def hasPythonFlagNoDocStrings():
function hasPythonFlagNoWarnings (line 2143) | def hasPythonFlagNoWarnings():
function hasPythonFlagIsolated (line 2149) | def hasPythonFlagIsolated():
function hasPythonFlagTraceImports (line 2155) | def hasPythonFlagTraceImports():
function hasPythonFlagNoRandomization (line 2161) | def hasPythonFlagNoRandomization():
function hasPythonFlagUnbuffered (line 2167) | def hasPythonFlagUnbuffered():
function hasPythonFlagPackageMode (line 2173) | def hasPythonFlagPackageMode():
function shallNotUseDependsExeCachedResults (line 2179) | def shallNotUseDependsExeCachedResults():
function shallNotStoreDependsExeCachedResults (line 2186) | def shallNotStoreDependsExeCachedResults():
function getPluginNameConsideringRenames (line 2191) | def getPluginNameConsideringRenames(plugin_name):
function getPluginsEnabled (line 2204) | def getPluginsEnabled():
function getPluginsDisabled (line 2223) | def getPluginsDisabled():
function getUserPlugins (line 2243) | def getUserPlugins():
function shallDetectMissingPlugins (line 2251) | def shallDetectMissingPlugins():
function getPythonPathForScons (line 2256) | def getPythonPathForScons():
function shallCompileWithoutBuildDirectory (line 2261) | def shallCompileWithoutBuildDirectory():
function shallPreferSourceCodeOverExtensionModules (line 2274) | def shallPreferSourceCodeOverExtensionModules():
function shallUseProgressBar (line 2279) | def shallUseProgressBar():
function getForcedStdoutPath (line 2284) | def getForcedStdoutPath():
function getForcedStderrPath (line 2294) | def getForcedStderrPath():
function shallShowSourceModifications (line 2304) | def shallShowSourceModifications(module_name):
function isLowMemory (line 2314) | def isLowMemory():
function getCompilationReportFilename (line 2319) | def getCompilationReportFilename():
function getCompilationReportTemplates (line 2324) | def getCompilationReportTemplates():
function getCompilationReportUserData (line 2333) | def getCompilationReportUserData():
function shallCreateDiffableCompilationReport (line 2368) | def shallCreateDiffableCompilationReport():
function getUserProvidedYamlFiles (line 2373) | def getUserProvidedYamlFiles():
function _getWarningMnemonicsDisabled (line 2378) | def _getWarningMnemonicsDisabled():
function shallDisplayWarningMnemonic (line 2382) | def shallDisplayWarningMnemonic(mnemonic):
function shallShowExecutedCommands (line 2391) | def shallShowExecutedCommands():
function getFcfProtectionMode (line 2395) | def getFcfProtectionMode():
function getModuleParameter (line 2400) | def getModuleParameter(module_name, parameter_name):
function getForcedRuntimeEnvironmentVariableValues (line 2413) | def getForcedRuntimeEnvironmentVariableValues():
FILE: nuitka/OutputDirectories.py
function setMainModule (line 27) | def setMainModule(main_module):
function getSourceDirectoryPath (line 37) | def getSourceDirectoryPath(onefile=False):
function _getStandaloneDistSuffix (line 60) | def _getStandaloneDistSuffix(bundle):
function getStandaloneDirectoryPath (line 69) | def getStandaloneDirectoryPath(bundle=True):
function getResultBasePath (line 84) | def getResultBasePath(onefile=False):
function getResultFullpath (line 103) | def getResultFullpath(onefile):
function getResultRunFilename (line 140) | def getResultRunFilename(onefile):
function getTreeFilenameWithSuffix (line 149) | def getTreeFilenameWithSuffix(module, suffix):
function getPgoRunExecutable (line 153) | def getPgoRunExecutable():
function getPgoRunInputFilename (line 157) | def getPgoRunInputFilename():
FILE: nuitka/PostProcessing.py
class IconDirectoryHeader (line 52) | class IconDirectoryHeader(ctypes.Structure):
class IconDirectoryEntry (line 60) | class IconDirectoryEntry(ctypes.Structure):
class IconGroupDirectoryEntry (line 73) | class IconGroupDirectoryEntry(ctypes.Structure):
function readFromFile (line 89) | def readFromFile(readable, c_struct):
function _addWindowsIconFromIcons (line 98) | def _addWindowsIconFromIcons(onefile):
function executePostProcessingResources (line 210) | def executePostProcessingResources(manifest, onefile):
function executePostProcessing (line 278) | def executePostProcessing():
FILE: nuitka/Progress.py
class NuitkaProgressBar (line 27) | class NuitkaProgressBar(object):
method __init__ (line 28) | def __init__(self, iterable, stage, total, min_total, unit):
method __iter__ (line 57) | def __iter__(self):
method updateTotal (line 60) | def updateTotal(self, total):
method setCurrent (line 65) | def setCurrent(self, item):
method update (line 74) | def update(self):
method clear (line 78) | def clear(self):
method close (line 81) | def close(self):
method withExternalWritingPause (line 85) | def withExternalWritingPause(self):
function _getTqdmModule (line 90) | def _getTqdmModule():
function enableProgressBar (line 123) | def enableProgressBar():
function setupProgressBar (line 139) | def setupProgressBar(stage, unit, total, min_total=0):
function reportProgressBar (line 153) | def reportProgressBar(item, total=None, update=True):
function closeProgressBar (line 169) | def closeProgressBar():
function wrapWithProgressBar (line 186) | def wrapWithProgressBar(iterable, stage, unit):
function withNuitkaDownloadProgressBar (line 200) | def withNuitkaDownloadProgressBar(*args, **kwargs):
FILE: nuitka/PythonFlavors.py
function isNuitkaPython (line 43) | def isNuitkaPython():
function isAnacondaPython (line 57) | def isAnacondaPython():
function isApplePython (line 69) | def isApplePython():
function isHomebrewPython (line 97) | def isHomebrewPython():
function isPyenvPython (line 116) | def isPyenvPython():
function isMSYS2MingwPython (line 125) | def isMSYS2MingwPython():
function isTermuxPython (line 138) | def isTermuxPython():
function isUninstalledPython (line 148) | def isUninstalledPython():
function isWinPython (line 180) | def isWinPython():
function isDebianPackagePython (line 200) | def isDebianPackagePython():
function isFedoraPackagePython (line 220) | def isFedoraPackagePython():
function isAlpinePackagePython (line 230) | def isAlpinePackagePython():
function isArchPackagePython (line 240) | def isArchPackagePython():
function isCPythonOfficialPackage (line 250) | def isCPythonOfficialPackage():
function isSelfCompiledPythonUninstalled (line 273) | def isSelfCompiledPythonUninstalled():
function isManyLinuxPython (line 288) | def isManyLinuxPython():
function isGithubActionsPython (line 305) | def isGithubActionsPython():
function getPythonFlavorName (line 313) | def getPythonFlavorName():
FILE: nuitka/PythonOperators.py
function matchException (line 110) | def matchException(left, right):
FILE: nuitka/PythonVersions.py
function getSupportedPythonVersions (line 20) | def getSupportedPythonVersions():
function getNotYetSupportedPythonVersions (line 37) | def getNotYetSupportedPythonVersions():
function getPartiallySupportedPythonVersions (line 42) | def getPartiallySupportedPythonVersions():
function getZstandardSupportingVersions (line 48) | def getZstandardSupportingVersions():
function getTestExecutionPythonVersions (line 61) | def getTestExecutionPythonVersions():
function getSupportedPythonVersionStr (line 83) | def getSupportedPythonVersionStr():
function _getPythonVersion (line 94) | def _getPythonVersion():
function getErrorMessageExecWithNestedFunction (line 106) | def getErrorMessageExecWithNestedFunction():
function getComplexCallSequenceErrorTemplate (line 127) | def getComplexCallSequenceErrorTemplate():
function getUnboundLocalErrorErrorTemplate (line 148) | def getUnboundLocalErrorErrorTemplate():
function needsSetLiteralReverseInsertion (line 166) | def needsSetLiteralReverseInsertion():
function needsDuplicateArgumentColOffset (line 182) | def needsDuplicateArgumentColOffset():
function getRunningPythonDLLPath (line 189) | def getRunningPythonDLLPath():
function getTargetPythonDLLPath (line 199) | def getTargetPythonDLLPath():
function isStaticallyLinkedPython (line 221) | def isStaticallyLinkedPython():
function getPythonABI (line 238) | def getPythonABI():
function getSystemPrefixPath (line 258) | def getSystemPrefixPath():
function getFutureModuleKeys (line 331) | def getFutureModuleKeys():
function getImportlibSubPackages (line 351) | def getImportlibSubPackages():
function isDebugPython (line 363) | def isDebugPython():
function _getFloatDigitBoundaryValue (line 368) | def _getFloatDigitBoundaryValue():
function isPythonValidDigitValue (line 382) | def isPythonValidDigitValue(value):
function isPythonValidCLongValue (line 405) | def isPythonValidCLongValue(value):
function isPythonValidCLongLongValue (line 409) | def isPythonValidCLongLongValue(value):
function getInstalledPythonRegistryPaths (line 413) | def getInstalledPythonRegistryPaths(version):
function getTkInterVersion (line 448) | def getTkInterVersion():
function getModuleLinkerLibs (line 460) | def getModuleLinkerLibs():
FILE: nuitka/Serialization.py
class BuiltinAnonValue (line 35) | class BuiltinAnonValue(object):
method __init__ (line 41) | def __init__(self, anon_name):
method getStreamValueByte (line 44) | def getStreamValueByte(self):
class BuiltinGenericAliasValue (line 50) | class BuiltinGenericAliasValue(object):
method __init__ (line 53) | def __init__(self, origin, args):
class BuiltinUnionTypeValue (line 58) | class BuiltinUnionTypeValue(object):
method __init__ (line 61) | def __init__(self, args):
class BuiltinSpecialValue (line 65) | class BuiltinSpecialValue(object):
method __init__ (line 68) | def __init__(self, value):
method getStreamValueByte (line 71) | def getStreamValueByte(self):
class BlobData (line 85) | class BlobData(object):
method __init__ (line 90) | def __init__(self, data, name):
method getData (line 94) | def getData(self):
method __repr__ (line 97) | def __repr__(self):
function _pickleAnonValues (line 101) | def _pickleAnonValues(pickler, value):
function _pickleGenericAlias (line 114) | def _pickleGenericAlias(pickler, value):
function _pickleUnionType (line 118) | def _pickleUnionType(pickler, value):
class ConstantStreamWriter (line 122) | class ConstantStreamWriter(object):
method __init__ (line 125) | def __init__(self, filename):
method addConstantValue (line 145) | def addConstantValue(self, constant_value):
method addBlobData (line 149) | def addBlobData(self, data, name):
method close (line 153) | def close(self):
class ConstantStreamReader (line 157) | class ConstantStreamReader(object):
method __init__ (line 158) | def __init__(self, const_file):
method readConstantValue (line 162) | def readConstantValue(self):
class ConstantAccessor (line 166) | class ConstantAccessor(object):
method __init__ (line 167) | def __init__(self, data_filename, top_level_name):
method getConstantCode (line 173) | def getConstantCode(self, constant):
method getBlobDataCode (line 241) | def getBlobDataCode(self, data, name):
method getConstantsCount (line 252) | def getConstantsCount(self):
FILE: nuitka/SourceCodeReferences.py
class SourceCodeReference (line 19) | class SourceCodeReference(object):
method fromFilenameAndLine (line 23) | def fromFilenameAndLine(cls, filename, line):
method __init__ (line 35) | def __init__(self):
method __repr__ (line 40) | def __repr__(self):
method __hash__ (line 43) | def __hash__(self):
method __lt__ (line 46) | def __lt__(self, other):
method __eq__ (line 73) | def __eq__(self, other):
method _clone (line 93) | def _clone(self, line):
method atInternal (line 97) | def atInternal(self):
method atLineNumber (line 110) | def atLineNumber(self, line):
method atColumnNumber (line 124) | def atColumnNumber(self, column):
method getLineNumber (line 134) | def getLineNumber(self):
method getColumnNumber (line 137) | def getColumnNumber(self):
method getFilename (line 140) | def getFilename(self):
method getAsString (line 143) | def getAsString(self):
method isInternal (line 147) | def isInternal():
class SourceCodeReferenceInternal (line 151) | class SourceCodeReferenceInternal(SourceCodeReference):
method isInternal (line 155) | def isInternal():
function fromFilename (line 159) | def fromFilename(filename):
FILE: nuitka/Tracing.py
function setQuiet (line 32) | def setQuiet():
function printIndented (line 38) | def printIndented(level, *what):
function printSeparator (line 42) | def printSeparator(level=0):
function printLine (line 46) | def printLine(*what, **kwargs):
function printError (line 55) | def printError(message):
function flushStandardOutputs (line 59) | def flushStandardOutputs():
function _getEnableStyleCode (line 64) | def _getEnableStyleCode(style):
function _enableAnsi (line 90) | def _enableAnsi():
function _getDisableStyleCode (line 103) | def _getDisableStyleCode():
function _getIoctlGWINSZ (line 107) | def _getIoctlGWINSZ(fd):
function _getTerminalSizeWin32 (line 119) | def _getTerminalSizeWin32():
function _getTerminalSize (line 152) | def _getTerminalSize():
function _aliasStyle (line 176) | def _aliasStyle(style):
function _my_print (line 199) | def _my_print(file_output, is_atty, args, kwargs):
function my_print (line 233) | def my_print(*args, **kwargs):
class ReportingSystemExit (line 251) | class ReportingSystemExit(SystemExit):
method __init__ (line 254) | def __init__(self, exit_code, exit_message):
class OurLogger (line 260) | class OurLogger(object):
method __init__ (line 261) | def __init__(self, name, quiet=False, base_style=None):
method my_print (line 266) | def my_print(self, message, **kwargs):
method _warnMnemonic (line 271) | def _warnMnemonic(mnemonic, style, output_function):
method _printFormatted (line 285) | def _printFormatted(self, prefix, message, style, keep_format):
method warning (line 305) | def warning(self, message, style="yellow", mnemonic=None, keep_format=...
method sysexit (line 324) | def sysexit(
method sysexit_exception (line 356) | def sysexit_exception(self, message, exception, exit_code=1):
method isQuiet (line 362) | def isQuiet(self):
method info (line 365) | def info(self, message, style=None, mnemonic=None, prefix=None, keep_f...
class FileLogger (line 382) | class FileLogger(OurLogger):
method __init__ (line 383) | def __init__(self, name, quiet=False, base_style=None, file_handle=None):
method my_print (line 388) | def my_print(self, message, **kwargs):
method setFileHandle (line 395) | def setFileHandle(self, file_handle):
method isFileOutput (line 398) | def isFileOutput(self):
method info (line 401) | def info(self, message, style=None, mnemonic=None):
method debug (line 411) | def debug(self, message, style=None):
method info_to_file_only (line 418) | def info_to_file_only(self, message, style=None):
method info_if_file (line 422) | def info_if_file(self, message, other_logger, style=None):
FILE: nuitka/TreeXML.py
function _indent (line 13) | def _indent(elem, level=0, more_sibs=False):
function _dedent (line 40) | def _dedent(elem, level=0):
function xml_tostring (line 60) | def xml_tostring(tree, indent=True, encoding=None):
function toBytes (line 83) | def toBytes(tree, indent=True, encoding=None):
function toString (line 87) | def toString(tree):
function fromString (line 96) | def fromString(text):
function fromFile (line 100) | def fromFile(file_handle, use_lxml=False):
function appendTreeElement (line 109) | def appendTreeElement(parent, *args, **kwargs):
function dumpTreeXMLToFile (line 117) | def dumpTreeXMLToFile(tree, output_file):
FILE: nuitka/Variables.py
class Variable (line 28) | class Variable(getMetaClassBase("Variable", require_slots=True)):
method __init__ (line 43) | def __init__(self, owner, variable_name):
method finalize (line 63) | def finalize(self):
method __repr__ (line 69) | def __repr__(self):
method getVariableType (line 77) | def getVariableType(self):
method getDescription (line 80) | def getDescription(self):
method getName (line 83) | def getName(self):
method getOwner (line 86) | def getOwner(self):
method getEntryPoint (line 89) | def getEntryPoint(self):
method getCodeName (line 92) | def getCodeName(self):
method allocateTargetNumber (line 99) | def allocateTargetNumber(self):
method isLocalVariable (line 105) | def isLocalVariable():
method isParameterVariable (line 109) | def isParameterVariable():
method isModuleVariable (line 113) | def isModuleVariable():
method isIncompleteModuleVariable (line 117) | def isIncompleteModuleVariable():
method isTempVariable (line 121) | def isTempVariable():
method isTempVariableBool (line 125) | def isTempVariableBool():
method isLocalsDictVariable (line 129) | def isLocalsDictVariable():
method addVariableUser (line 132) | def addVariableUser(self, user):
method isSharedTechnically (line 148) | def isSharedTechnically(self):
method addTrace (line 171) | def addTrace(self, variable_trace):
method removeTrace (line 174) | def removeTrace(self, variable_trace):
method getTraces (line 177) | def getTraces(self):
method updateUsageState (line 181) | def updateUsageState(self):
method hasAccessesOutsideOf (line 197) | def hasAccessesOutsideOf(self, provider):
method hasWritersOutsideOf (line 207) | def hasWritersOutsideOf(self, provider):
method getMatchingAssignTrace (line 222) | def getMatchingAssignTrace(self, assign_node):
method getMatchingUnescapedAssignTrace (line 229) | def getMatchingUnescapedAssignTrace(self, assign_node):
method getMatchingDelTrace (line 239) | def getMatchingDelTrace(self, del_node):
method getTypeShapes (line 246) | def getTypeShapes(self):
method onControlFlowEscape (line 271) | def onControlFlowEscape(trace_collection):
method removeKnowledge (line 274) | def removeKnowledge(self, trace_collection):
method removeAllKnowledge (line 278) | def removeAllKnowledge(self, trace_collection):
class LocalVariable (line 283) | class LocalVariable(Variable):
method __init__ (line 286) | def __init__(self, owner, variable_name):
method isLocalVariable (line 290) | def isLocalVariable():
method initVariable (line 293) | def initVariable(self, trace_collection):
method onControlFlowEscape (line 299) | def onControlFlowEscape(self, trace_collection):
method onControlFlowEscape (line 307) | def onControlFlowEscape(self, trace_collection):
method getVariableType (line 312) | def getVariableType():
class ParameterVariable (line 316) | class ParameterVariable(LocalVariable):
method __init__ (line 319) | def __init__(self, owner, parameter_name):
method getDescription (line 322) | def getDescription(self):
method isParameterVariable (line 326) | def isParameterVariable():
method initVariable (line 329) | def initVariable(self, trace_collection):
class ModuleVariable (line 334) | class ModuleVariable(Variable):
method __init__ (line 337) | def __init__(self, module, variable_name):
method __repr__ (line 343) | def __repr__(self):
method getDescription (line 349) | def getDescription(self):
method isModuleVariable (line 353) | def isModuleVariable():
method initVariable (line 356) | def initVariable(self, trace_collection):
method onControlFlowEscape (line 360) | def onControlFlowEscape(self, trace_collection):
method removeKnowledge (line 363) | def removeKnowledge(self, trace_collection):
method isIncompleteModuleVariable (line 367) | def isIncompleteModuleVariable(self):
method hasDefiniteWrites (line 370) | def hasDefiniteWrites(self):
method getModule (line 376) | def getModule(self):
method getVariableType (line 380) | def getVariableType():
class TempVariable (line 384) | class TempVariable(Variable):
method __init__ (line 387) | def __init__(self, owner, variable_name, variable_type):
method isTempVariable (line 394) | def isTempVariable():
method getVariableType (line 397) | def getVariableType(self):
method isTempVariableBool (line 400) | def isTempVariableBool(self):
method getDescription (line 403) | def getDescription(self):
method initVariable (line 406) | def initVariable(self, trace_collection):
method removeAllKnowledge (line 411) | def removeAllKnowledge(trace_collection):
class LocalsDictVariable (line 417) | class LocalsDictVariable(Variable):
method __init__ (line 420) | def __init__(self, owner, variable_name):
method isLocalsDictVariable (line 424) | def isLocalsDictVariable():
method getVariableType (line 428) | def getVariableType():
method initVariable (line 431) | def initVariable(self, trace_collection):
function updateVariablesFromCollection (line 439) | def updateVariablesFromCollection(old_collection, new_collection, source...
function isSharedAmongScopes (line 489) | def isSharedAmongScopes(variable):
function releaseSharedScopeInformation (line 493) | def releaseSharedScopeInformation(tree):
FILE: nuitka/Version.py
function getNuitkaVersion (line 27) | def getNuitkaVersion():
function parseNuitkaVersionToTuple (line 39) | def parseNuitkaVersionToTuple(version):
function getNuitkaVersionTuple (line 64) | def getNuitkaVersionTuple():
function getNuitkaVersionYear (line 75) | def getNuitkaVersionYear():
function getCommercialVersion (line 81) | def getCommercialVersion():
FILE: nuitka/__main__.py
function main (line 18) | def main():
FILE: nuitka/__past__.py
function iterItems (line 40) | def iterItems(d):
function iterItems (line 45) | def iterItems(d):
function total_ordering (line 81) | def total_ordering(cls):
function to_byte (line 106) | def to_byte(value):
function from_byte (line 110) | def from_byte(value):
function iter_modules (line 153) | def iter_modules(path=None, prefix=""):
function md5 (line 176) | def md5(value=b""):
FILE: nuitka/build/DataComposerInterface.py
function getDataComposerReportValues (line 24) | def getDataComposerReportValues():
function runDataComposer (line 28) | def runDataComposer(source_dir):
function _runDataComposer (line 42) | def _runDataComposer(source_dir):
function getConstantBlobFilename (line 80) | def getConstantBlobFilename(source_dir):
function deriveModuleConstantsBlobName (line 84) | def deriveModuleConstantsBlobName(filename):
FILE: nuitka/build/SconsCaching.py
function _getPythonDirCandidates (line 38) | def _getPythonDirCandidates(python_prefix):
function _getCcacheGuessedPaths (line 52) | def _getCcacheGuessedPaths(python_prefix):
function _injectCcache (line 62) | def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
function enableCcache (line 139) | def enableCcache(
function enableClcache (line 201) | def enableClcache(env, source_dir):
function _writeClcacheStatistics (line 252) | def _writeClcacheStatistics():
function _getCcacheStatistics (line 268) | def _getCcacheStatistics(ccache_logfile):
function checkCachingSuccess (line 330) | def checkCachingSuccess(source_dir):
function runClCache (line 406) | def runClCache(args, env):
FILE: nuitka/build/SconsCompilerSettings.py
function _detectWindowsSDK (line 49) | def _detectWindowsSDK(env):
function _enableC11Settings (line 83) | def _enableC11Settings(env):
function _enableLtoSettings (line 130) | def _enableLtoSettings(
function checkWindowsCompilerFound (line 253) | def checkWindowsCompilerFound(
function decideConstantsBlobResourceMode (line 420) | def decideConstantsBlobResourceMode(env, module_mode):
function addConstantBlobFile (line 448) | def addConstantBlobFile(env, blob_filename, resource_desc, target_arch):
function enableWindowsStackSize (line 573) | def enableWindowsStackSize(env, target_arch):
function setupCCompiler (line 587) | def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
function _enablePgoSettings (line 827) | def _enablePgoSettings(env, pgo_mode):
function _enableDebugSystemSettings (line 875) | def _enableDebugSystemSettings(env, job_count):
function switchFromGccToGpp (line 900) | def switchFromGccToGpp(env):
function reportCCompiler (line 976) | def reportCCompiler(env, context, output_func):
function importEnvironmentVariableSettings (line 1000) | def importEnvironmentVariableSettings(env):
FILE: nuitka/build/SconsHacks.py
function _myDetectVersion (line 76) | def _myDetectVersion(cc):
function myDetectVersion (line 116) | def myDetectVersion(env, cc):
function myDetect (line 137) | def myDetect(self, progs):
function getEnhancedToolDetect (line 154) | def getEnhancedToolDetect():
function makeGccUseLinkerFile (line 169) | def makeGccUseLinkerFile(source_files, module_mode, env):
FILE: nuitka/build/SconsInterface.py
function getSconsDataPath (line 64) | def getSconsDataPath():
function _getSconsInlinePath (line 70) | def _getSconsInlinePath():
function _getSconsBinaryCall (line 76) | def _getSconsBinaryCall():
function _getPythonForSconsExePath (line 103) | def _getPythonForSconsExePath():
function _setupSconsEnvironment2 (line 145) | def _setupSconsEnvironment2():
function _setupSconsEnvironment (line 189) | def _setupSconsEnvironment():
function _buildSconsCommand (line 212) | def _buildSconsCommand(options, scons_filename):
function _createSconsDebugScript (line 263) | def _createSconsDebugScript(source_dir, scons_command):
function runScons (line 318) | def runScons(options, env_values, scons_filename):
function asBoolStr (line 379) | def asBoolStr(value):
function cleanSconsDirectory (line 385) | def cleanSconsDirectory(source_dir):
function setCommonSconsOptions (line 431) | def setCommonSconsOptions(options):
FILE: nuitka/build/SconsProgress.py
function enableSconsProgressBar (line 19) | def enableSconsProgressBar():
function setSconsProgressBarTotal (line 32) | def setSconsProgressBarTotal(name, total):
function updateSconsProgressBar (line 41) | def updateSconsProgressBar():
function closeSconsProgressBar (line 57) | def closeSconsProgressBar():
function reportSlowCompilation (line 61) | def reportSlowCompilation(env, cmd, delta_time):
FILE: nuitka/build/SconsSpawn.py
class SubprocessThread (line 29) | class SubprocessThread(threading.Thread):
method __init__ (line 30) | def __init__(self, cmdline, env):
method run (line 48) | def run(self):
method getProcessResult (line 59) | def getProcessResult(self):
function _runProcessMonitored (line 63) | def _runProcessMonitored(env, cmdline, os_env):
function _filterMsvcLinkOutput (line 80) | def _filterMsvcLinkOutput(env, module_mode, data, exit_code):
function _raiseCorruptedObjectFilesExit (line 106) | def _raiseCorruptedObjectFilesExit(cache_name):
function _getNoSuchCommandErrorMessage (line 117) | def _getNoSuchCommandErrorMessage():
function _getWindowsSpawnFunction (line 125) | def _getWindowsSpawnFunction(env, module_mode, source_files):
function _formatForOutput (line 230) | def _formatForOutput(arg):
function isIgnoredError (line 250) | def isIgnoredError(line):
function subprocess_spawn (line 301) | def subprocess_spawn(env, args):
class SpawnThread (line 335) | class SpawnThread(threading.Thread):
method __init__ (line 336) | def __init__(self, env, *args):
method run (line 356) | def run(self):
method getSpawnResult (line 364) | def getSpawnResult(self):
function _runSpawnMonitored (line 368) | def _runSpawnMonitored(env, sh, cmd, args, os_env):
function _getWrappedSpawnFunction (line 385) | def _getWrappedSpawnFunction(env):
function enableSpawnMonitoring (line 418) | def enableSpawnMonitoring(env, module_mode, source_files):
FILE: nuitka/build/SconsUtils.py
function initScons (line 32) | def initScons():
function setupScons (line 46) | def setupScons(env, source_dir):
function setArguments (line 64) | def setArguments(arguments):
function getArgumentRequired (line 75) | def getArgumentRequired(name):
function getArgumentDefaulted (line 80) | def getArgumentDefaulted(name, default):
function getArgumentInt (line 85) | def getArgumentInt(option_name, default=None):
function getArgumentBool (line 95) | def getArgumentBool(option_name, default=None):
function getArgumentList (line 105) | def getArgumentList(option_name, default=None):
function _enableFlagSettings (line 118) | def _enableFlagSettings(env, name, experimental_flags):
function prepareEnvironment (line 141) | def prepareEnvironment(mingw_mode):
function createEnvironment (line 173) | def createEnvironment(
function decodeData (line 275) | def decodeData(data):
function getExecutablePath (line 288) | def getExecutablePath(filename, env):
function changeKeyboardInterruptToErrorExit (line 324) | def changeKeyboardInterruptToErrorExit():
function setEnvironmentVariable (line 333) | def setEnvironmentVariable(env, key, value):
function addToPATH (line 347) | def addToPATH(env, dirname, prefix):
function writeSconsReport (line 362) | def writeSconsReport(env):
function reportSconsUnexpectedOutput (line 395) | def reportSconsUnexpectedOutput(env, cmdline, stdout, stderr):
function flushSconsReports (line 408) | def flushSconsReports():
function _getSconsReportFilename (line 413) | def _getSconsReportFilename(source_dir):
function _getSconsErrorReportFilename (line 417) | def _getSconsErrorReportFilename(source_dir):
function readSconsReport (line 421) | def readSconsReport(source_dir):
function getSconsReportValue (line 440) | def getSconsReportValue(source_dir, key):
function readSconsErrorReport (line 444) | def readSconsErrorReport(source_dir):
function addClangClPathFromMSVC (line 485) | def addClangClPathFromMSVC(env):
function isGccName (line 530) | def isGccName(cc_name):
function isClangName (line 539) | def isClangName(cc_name):
function isZigName (line 543) | def isZigName(cc_name):
function cheapCopyFile (line 547) | def cheapCopyFile(src, dst):
function provideStaticSourceFile (line 585) | def provideStaticSourceFile(env, sub_path, c11_mode):
function scanSourceDir (line 599) | def scanSourceDir(env, dirname, plugins):
function makeCLiteral (line 639) | def makeCLiteral(value):
function createDefinitionsFile (line 646) | def createDefinitionsFile(source_dir, filename, definitions):
function getMsvcVersionString (line 667) | def getMsvcVersionString(env):
function getMsvcVersion (line 673) | def getMsvcVersion(env):
function _getBinaryArch (line 684) | def _getBinaryArch(binary, mingw_mode):
function getLinkerArch (line 728) | def getLinkerArch(target_arch, mingw_mode):
function getCompilerArch (line 753) | def getCompilerArch(mingw_mode, msvc_mode, the_cc_name, compiler_path):
function decideArchMismatch (line 789) | def decideArchMismatch(target_arch, the_cc_name, compiler_path):
function raiseNoCompilerFoundErrorExit (line 804) | def raiseNoCompilerFoundErrorExit():
function addBinaryBlobSection (line 824) | def addBinaryBlobSection(env, blob_filename, section_name):
FILE: nuitka/build/include/nuitka/allocator.h
function _Nuitka_Py_DECREF (line 18) | static inline void _Nuitka_Py_DECREF(PyObject *ob) {
function _Nuitka_Py_XDECREF (line 39) | static inline void _Nuitka_Py_XDECREF(PyObject *ob) {
function _Py_SET_TYPE (line 76) | static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { ob->...
function Nuitka_Py_NewReference (line 83) | static void Nuitka_Py_NewReference(PyObject *op) {
function Nuitka_PyType_HasFeature (line 93) | static inline int Nuitka_PyType_HasFeature(PyTypeObject *type, unsigned ...
function Nuitka_PyType_PreHeaderSize (line 99) | static inline size_t Nuitka_PyType_PreHeaderSize(PyTypeObject *tp) {
function PyObject (line 106) | static PyObject *Nuitka_PyType_AllocNoTrackVar(PyTypeObject *type, Py_ss...
function PyObject (line 145) | static PyObject *Nuitka_PyType_AllocNoTrack(PyTypeObject *type) {
function NUITKA_MAY_BE_UNUSED (line 172) | NUITKA_MAY_BE_UNUSED static void *Nuitka_GC_NewVar(PyTypeObject *type, P...
function NUITKA_MAY_BE_UNUSED (line 202) | NUITKA_MAY_BE_UNUSED static void *Nuitka_GC_New(PyTypeObject *type) {
FILE: nuitka/build/include/nuitka/builtins.h
function NUITKA_MAY_BE_UNUSED (line 11) | NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_BUILTIN(PyObject *name) {
function NUITKA_MAY_BE_UNUSED (line 30) | NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_BUILTIN_STR(char const *nam...
function NUITKA_MAY_BE_UNUSED (line 75) | NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_SysGetObject(char const *na...
function NUITKA_MAY_BE_UNUSED (line 77) | NUITKA_MAY_BE_UNUSED static void Nuitka_SysSetObject(char const *name, P...
FILE: nuitka/build/include/nuitka/calling.h
function NUITKA_MAY_BE_UNUSED (line 18) | NUITKA_MAY_BE_UNUSED static inline PyObject *Nuitka_CheckFunctionResult(...
function NUITKA_MAY_BE_UNUSED (line 51) | NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION(PyThreadState *tstat...
function NUITKA_MAY_BE_UNUSED (line 84) | NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION_WITH_POSARGS(PyThrea...
function NUITKA_MAY_BE_UNUSED (line 94) | NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION_WITH_KEYARGS(PyThrea...
FILE: nuitka/build/include/nuitka/compiled_asyncgen.h
type Nuitka_AsyncgenObject (line 20) | struct Nuitka_AsyncgenObject {
type PyObject (line 91) | typedef PyObject *(*asyncgen_code)(PyThreadState *tstate, struct Nuitka_...
type Nuitka_CellObject (line 94) | struct Nuitka_CellObject
function Nuitka_Asyncgen_Check (line 97) | static inline bool Nuitka_Asyncgen_Check(PyObject *object) { return Py_T...
function SAVE_ASYNCGEN_EXCEPTION (line 99) | static inline void SAVE_ASYNCGEN_EXCEPTION(PyThreadState *tstate, struct...
function RESTORE_ASYNCGEN_EXCEPTION (line 155) | static inline void RESTORE_ASYNCGEN_EXCEPTION(PyThreadState *tstate, str...
function NUITKA_MAY_BE_UNUSED (line 212) | NUITKA_MAY_BE_UNUSED static void STORE_ASYNCGEN_EXCEPTION(PyThreadState ...
function NUITKA_MAY_BE_UNUSED (line 229) | NUITKA_MAY_BE_UNUSED static void DROP_ASYNCGEN_EXCEPTION(struct Nuitka_A...
FILE: nuitka/build/include/nuitka/compiled_cell.h
function Nuitka_Cell_Check (line 12) | static inline bool Nuitka_Cell_Check(PyObject *object) { return Py_TYPE(...
type Nuitka_CellObject (line 14) | struct Nuitka_CellObject {
type Nuitka_CellObject (line 23) | struct Nuitka_CellObject
type Nuitka_CellObject (line 24) | struct Nuitka_CellObject
type Nuitka_CellObject (line 25) | struct Nuitka_CellObject
FILE: nuitka/build/include/nuitka/compiled_coroutine.h
type Nuitka_CoroutineObject (line 20) | struct Nuitka_CoroutineObject {
type PyObject (line 84) | typedef PyObject *(*coroutine_code)(PyThreadState *tstate, struct Nuitka...
type Nuitka_CellObject (line 87) | struct Nuitka_CellObject
function Nuitka_Coroutine_Check (line 90) | static inline bool Nuitka_Coroutine_Check(PyObject *object) { return Py_...
type Nuitka_CoroutineWrapperObject (line 92) | struct Nuitka_CoroutineWrapperObject {
function Nuitka_CoroutineWrapper_Check (line 101) | static inline bool Nuitka_CoroutineWrapper_Check(PyObject *object) {
function SAVE_COROUTINE_EXCEPTION (line 105) | static inline void SAVE_COROUTINE_EXCEPTION(PyThreadState *tstate, struc...
function RESTORE_COROUTINE_EXCEPTION (line 151) | static inline void RESTORE_COROUTINE_EXCEPTION(PyThreadState *tstate, st...
type Await_Kind (line 191) | enum Await_Kind {
type Generator_Status (line 197) | typedef int Generator_Status;
function NUITKA_MAY_BE_UNUSED (line 212) | NUITKA_MAY_BE_UNUSED static void STORE_COROUTINE_EXCEPTION(PyThreadState...
function NUITKA_MAY_BE_UNUSED (line 228) | NUITKA_MAY_BE_UNUSED static void DROP_COROUTINE_EXCEPTION(struct Nuitka_...
FILE: nuitka/build/include/nuitka/compiled_frame.h
type PyFrameObject (line 22) | typedef PyFrameObject Nuitka_ThreadStateFrameType;
type _PyInterpreterFrame (line 24) | typedef _PyInterpreterFrame Nuitka_ThreadStateFrameType;
type Nuitka_FrameObject (line 31) | struct Nuitka_FrameObject
type Nuitka_FrameObject (line 41) | struct Nuitka_FrameObject
type Nuitka_FrameObject (line 42) | struct Nuitka_FrameObject
type Nuitka_FrameObject (line 44) | struct Nuitka_FrameObject
function NUITKA_MAY_BE_UNUSED (line 78) | NUITKA_MAY_BE_UNUSED static inline bool isFakeCodeObject(PyCodeObject *c...
function Nuitka_Frame_Check (line 93) | static inline bool Nuitka_Frame_Check(PyObject *object) {
type Nuitka_FrameObject (line 98) | struct Nuitka_FrameObject {
function CHECK_CODE_OBJECT (line 120) | inline static void CHECK_CODE_OBJECT(PyCodeObject *code_object) { CHECK_...
function NUITKA_MAY_BE_UNUSED (line 122) | NUITKA_MAY_BE_UNUSED static inline bool isFrameUnusable(struct Nuitka_Fr...
function PyCodeObject (line 157) | inline static PyCodeObject *Nuitka_Frame_GetCodeObject(PyFrameObject *fr...
function assertPythonFrameObject (line 166) | inline static void assertPythonFrameObject(PyFrameObject *frame_object) {
function assertFrameObject (line 175) | inline static void assertFrameObject(struct Nuitka_FrameObject *frame_ob...
function assertThreadFrameObject (line 185) | inline static void assertThreadFrameObject(Nuitka_ThreadStateFrameType *...
function Nuitka_PythonFrame_MarkAsExecuting (line 205) | static inline void Nuitka_PythonFrame_MarkAsExecuting(PyFrameObject *fra...
function Nuitka_Frame_MarkAsExecuting (line 215) | static inline void Nuitka_Frame_MarkAsExecuting(struct Nuitka_FrameObjec...
function Nuitka_Frame_MarkAsNotExecuting (line 230) | static inline void Nuitka_Frame_MarkAsNotExecuting(struct Nuitka_FrameOb...
function Nuitka_Frame_IsExecuting (line 246) | static inline bool Nuitka_Frame_IsExecuting(struct Nuitka_FrameObject *f...
function NUITKA_MAY_BE_UNUSED (line 259) | NUITKA_MAY_BE_UNUSED inline static void pushFrameStackInterpreterFrame(P...
function NUITKA_MAY_BE_UNUSED (line 272) | NUITKA_MAY_BE_UNUSED inline static void pushFrameStackPythonFrame(PyThre...
function NUITKA_MAY_BE_UNUSED (line 306) | NUITKA_MAY_BE_UNUSED inline static void pushFrameStackCompiledFrame(PyTh...
function NUITKA_MAY_BE_UNUSED (line 318) | NUITKA_MAY_BE_UNUSED inline static void popFrameStack(PyThreadState *tst...
function NUITKA_MAY_BE_UNUSED (line 365) | NUITKA_MAY_BE_UNUSED static void Nuitka_SetFrameGenerator(struct Nuitka_...
function NUITKA_MAY_BE_UNUSED (line 379) | NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_GetFrameGenerator(struct Nu...
function NUITKA_MAY_BE_UNUSED (line 388) | NUITKA_MAY_BE_UNUSED static PyCodeObject *Nuitka_GetFrameCodeObject(stru...
function NUITKA_MAY_BE_UNUSED (line 396) | NUITKA_MAY_BE_UNUSED static int Nuitka_GetFrameLineNumber(struct Nuitka_...
function NUITKA_MAY_BE_UNUSED (line 400) | NUITKA_MAY_BE_UNUSED static PyObject **Nuitka_GetCodeVarNames(PyCodeObje...
type Nuitka_FrameObject (line 412) | struct Nuitka_FrameObject
function NUITKA_MAY_BE_UNUSED (line 414) | NUITKA_MAY_BE_UNUSED static Nuitka_ThreadStateFrameType *_Nuitka_GetThre...
function NUITKA_MAY_BE_UNUSED (line 422) | NUITKA_MAY_BE_UNUSED inline static void pushFrameStackGenerator(PyThread...
function NUITKA_MAY_BE_UNUSED (line 436) | NUITKA_MAY_BE_UNUSED inline static void pushFrameStackGeneratorCompiledF...
FILE: nuitka/build/include/nuitka/compiled_function.h
type Nuitka_FunctionObject (line 16) | struct Nuitka_FunctionObject
type PyObject (line 19) | typedef PyObject *(*function_impl_code)(PyThreadState *tstate, struct Nu...
type Nuitka_FunctionObject (line 23) | struct Nuitka_FunctionObject {
type Nuitka_FunctionObject (line 89) | struct Nuitka_FunctionObject
type Nuitka_CellObject (line 92) | struct Nuitka_CellObject
type Nuitka_FunctionObject (line 94) | struct Nuitka_FunctionObject
type Nuitka_CellObject (line 97) | struct Nuitka_CellObject
type Nuitka_FunctionObject (line 101) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 103) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 105) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 108) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 110) | struct Nuitka_FunctionObject
function Nuitka_Function_Check (line 117) | static inline bool Nuitka_Function_Check(PyObject *object) { return Py_T...
function PyObject (line 119) | static inline PyObject *Nuitka_Function_GetName(PyObject *object) {
type Nuitka_FunctionObject (line 123) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 125) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 128) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 131) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 133) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 137) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 139) | struct Nuitka_FunctionObject
type Nuitka_FunctionObject (line 141) | struct Nuitka_FunctionObject
FILE: nuitka/build/include/nuitka/compiled_generator.h
type Generator_Status (line 18) | enum Generator_Status {
type Generator_Status (line 24) | typedef int Generator_Status;
type PySendResult (line 32) | typedef enum {
type Nuitka_GeneratorObject (line 41) | struct Nuitka_GeneratorObject {
type PyObject (line 100) | typedef PyObject *(*generator_code)(PyThreadState *tstate, struct Nuitka...
type Nuitka_CellObject (line 106) | struct Nuitka_CellObject
type Nuitka_CellObject (line 113) | struct Nuitka_CellObject
type Nuitka_GeneratorObject (line 116) | struct Nuitka_GeneratorObject
function Nuitka_Generator_Check (line 119) | static inline bool Nuitka_Generator_Check(PyObject *object) { return Py_...
function PyObject (line 121) | static inline PyObject *Nuitka_Generator_GetName(PyObject *object) {
function SAVE_GENERATOR_EXCEPTION (line 125) | static inline void SAVE_GENERATOR_EXCEPTION(PyThreadState *tstate, struc...
function RESTORE_GENERATOR_EXCEPTION (line 176) | static inline void RESTORE_GENERATOR_EXCEPTION(PyThreadState *tstate, st...
function NUITKA_MAY_BE_UNUSED (line 219) | NUITKA_MAY_BE_UNUSED static void STORE_GENERATOR_EXCEPTION(PyThreadState...
function NUITKA_MAY_BE_UNUSED (line 235) | NUITKA_MAY_BE_UNUSED static void DROP_GENERATOR_EXCEPTION(struct Nuitka_...
FILE: nuitka/build/include/nuitka/compiled_method.h
type Nuitka_MethodObject (line 16) | struct Nuitka_MethodObject {
type Nuitka_FunctionObject (line 35) | struct Nuitka_FunctionObject
function Nuitka_Method_Check (line 37) | static inline bool Nuitka_Method_Check(PyObject *object) { return Py_TYP...
FILE: nuitka/build/include/nuitka/exception_groups.h
function NUITKA_MAY_BE_UNUSED (line 10) | NUITKA_MAY_BE_UNUSED static void FORMAT_CLASS_CATCH_ERROR(PyThreadState ...
function NUITKA_MAY_BE_UNUSED (line 15) | NUITKA_MAY_BE_UNUSED static int CHECK_EXCEPTION_TYPE_VALID(PyThreadState...
function NUITKA_MAY_BE_UNUSED (line 36) | NUITKA_MAY_BE_UNUSED static int CHECK_EXCEPTION_STAR_VALID(PyThreadState...
function NUITKA_MAY_BE_UNUSED (line 80) | NUITKA_MAY_BE_UNUSED static int EXCEPTION_GROUP_MATCH(PyThreadState *tst...
FILE: nuitka/build/include/nuitka/exceptions.h
function NUITKA_MAY_BE_UNUSED (line 14) | NUITKA_MAY_BE_UNUSED static inline bool HAS_ERROR_OCCURRED(PyThreadState...
function NUITKA_MAY_BE_UNUSED (line 23) | NUITKA_MAY_BE_UNUSED static inline PyObject *GET_ERROR_OCCURRED(PyThread...
function NUITKA_MAY_BE_UNUSED (line 32) | NUITKA_MAY_BE_UNUSED static inline void CLEAR_ERROR_OCCURRED(PyThreadSta...
function NUITKA_MAY_BE_UNUSED (line 53) | NUITKA_MAY_BE_UNUSED static inline bool DROP_ERROR_OCCURRED(PyThreadStat...
function NUITKA_MAY_BE_UNUSED (line 87) | NUITKA_MAY_BE_UNUSED static void FETCH_ERROR_OCCURRED(PyThreadState *tst...
function NUITKA_MAY_BE_UNUSED (line 105) | NUITKA_MAY_BE_UNUSED static void FETCH_ERROR_OCCURRED_UNTRACED(PyThreadS...
function NUITKA_MAY_BE_UNUSED (line 117) | NUITKA_MAY_BE_UNUSED static void RESTORE_ERROR_OCCURRED(PyThreadState *t...
function NUITKA_MAY_BE_UNUSED (line 138) | NUITKA_MAY_BE_UNUSED static void RESTORE_ERROR_OCCURRED_UNTRACED(PyThrea...
type Nuitka_FrameObject (line 155) | struct Nuitka_FrameObject
type Nuitka_FrameObject (line 157) | struct Nuitka_FrameObject
function NUITKA_MAY_BE_UNUSED (line 160) | NUITKA_MAY_BE_UNUSED static PyTracebackObject *ADD_TRACEBACK(PyTraceback...
type Nuitka_ExceptionStackItem (line 205) | struct Nuitka_ExceptionStackItem {
type Nuitka_ExceptionStackItem (line 212) | struct Nuitka_ExceptionStackItem
type Nuitka_ExceptionStackItem (line 218) | struct Nuitka_ExceptionStackItem {
type Nuitka_ExceptionStackItem (line 223) | struct Nuitka_ExceptionStackItem
function Nuitka_ExceptionStackItem (line 232) | Nuitka_ExceptionStackItem GET_CURRENT_EXCEPTION(PyThreadState *tstate) {
function NUITKA_MAY_BE_UNUSED (line 254) | NUITKA_MAY_BE_UNUSED inline static void SET_CURRENT_EXCEPTION(PyThreadSt...
function NUITKA_MAY_BE_UNUSED (line 326) | NUITKA_MAY_BE_UNUSED inline static void SET_CURRENT_EXCEPTION_TYPE0(PyTh...
function NUITKA_MAY_BE_UNUSED (line 366) | NUITKA_MAY_BE_UNUSED inline static void
function NUITKA_MAY_BE_UNUSED (line 402) | NUITKA_MAY_BE_UNUSED inline static void
function NUITKA_MAY_BE_UNUSED (line 439) | NUITKA_MAY_BE_UNUSED inline static void SET_CURRENT_EXCEPTION_TYPE0_STR(...
function NUITKA_MAY_BE_UNUSED (line 459) | NUITKA_MAY_BE_UNUSED static inline void PRESERVE_FRAME_EXCEPTION(PyThrea...
function NUITKA_MAY_BE_UNUSED (line 497) | NUITKA_MAY_BE_UNUSED static inline void RESTORE_FRAME_EXCEPTION(PyThread...
function NUITKA_MAY_BE_UNUSED (line 535) | NUITKA_MAY_BE_UNUSED static inline void ATTACH_TRACEBACK_TO_EXCEPTION_VA...
function NUITKA_MAY_BE_UNUSED (line 556) | NUITKA_MAY_BE_UNUSED static inline PyTracebackObject *GET_EXCEPTION_TRAC...
function NUITKA_MAY_BE_UNUSED (line 568) | NUITKA_MAY_BE_UNUSED static inline void NORMALIZE_EXCEPTION(PyThreadStat...
function NUITKA_MAY_BE_UNUSED (line 593) | NUITKA_MAY_BE_UNUSED static inline void PUBLISH_CURRENT_EXCEPTION(PyThre...
function NUITKA_MAY_BE_UNUSED (line 628) | NUITKA_MAY_BE_UNUSED static inline void ADD_EXCEPTION_CONTEXT(PyThreadSt...
function NUITKA_MAY_BE_UNUSED (line 644) | NUITKA_MAY_BE_UNUSED static bool _CHECK_AND_CLEAR_EXCEPTION_OCCURRED(PyT...
function NUITKA_MAY_BE_UNUSED (line 688) | NUITKA_MAY_BE_UNUSED static bool CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED...
function NUITKA_MAY_BE_UNUSED (line 698) | NUITKA_MAY_BE_UNUSED static bool CHECK_AND_CLEAR_KEY_ERROR_OCCURRED(PyTh...
function NUITKA_MAY_BE_UNUSED (line 702) | NUITKA_MAY_BE_UNUSED static bool CHECK_AND_CLEAR_ATTRIBUTE_ERROR_OCCURRE...
function NUITKA_MAY_BE_UNUSED (line 723) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_EXCEPTION_FROM_TYPE_ARG0(PyTh...
function NUITKA_MAY_BE_UNUSED (line 750) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_EXCEPTION_FROM_TYPE_ARG0(PyTh...
type Nuitka_ExceptionPreservationItem (line 758) | struct Nuitka_ExceptionPreservationItem {
function NUITKA_MAY_BE_UNUSED (line 764) | NUITKA_MAY_BE_UNUSED static void FETCH_ERROR_OCCURRED_STATE(PyThreadStat...
function NUITKA_MAY_BE_UNUSED (line 770) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 776) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 782) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 788) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 796) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 803) | NUITKA_MAY_BE_UNUSED static void INIT_ERROR_OCCURRED_STATE(struct Nuitka...
function NUITKA_MAY_BE_UNUSED (line 809) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 816) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 823) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 836) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 849) | NUITKA_MAY_BE_UNUSED static PyTracebackObject *
function NUITKA_MAY_BE_UNUSED (line 854) | NUITKA_MAY_BE_UNUSED static void SET_EXCEPTION_STATE_TRACEBACK(struct Nu...
function NUITKA_MAY_BE_UNUSED (line 861) | NUITKA_MAY_BE_UNUSED static bool HAS_EXCEPTION_STATE(struct Nuitka_Excep...
function NUITKA_MAY_BE_UNUSED (line 865) | NUITKA_MAY_BE_UNUSED static bool
function NUITKA_MAY_BE_UNUSED (line 871) | NUITKA_MAY_BE_UNUSED inline static void
function NUITKA_MAY_BE_UNUSED (line 878) | NUITKA_MAY_BE_UNUSED inline static void
type Nuitka_ExceptionPreservationItem (line 886) | struct Nuitka_ExceptionPreservationItem {
function NUITKA_MAY_BE_UNUSED (line 890) | NUITKA_MAY_BE_UNUSED static void FETCH_ERROR_OCCURRED_STATE(PyThreadStat...
function NUITKA_MAY_BE_UNUSED (line 902) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 908) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 921) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 929) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 935) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 940) | NUITKA_MAY_BE_UNUSED static void INIT_ERROR_OCCURRED_STATE(struct Nuitka...
function NUITKA_MAY_BE_UNUSED (line 944) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 949) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 954) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 962) | NUITKA_MAY_BE_UNUSED static void
function NUITKA_MAY_BE_UNUSED (line 970) | NUITKA_MAY_BE_UNUSED static PyTracebackObject *
function NUITKA_MAY_BE_UNUSED (line 975) | NUITKA_MAY_BE_UNUSED static void SET_EXCEPTION_STATE_TRACEBACK(struct Nu...
function NUITKA_MAY_BE_UNUSED (line 980) | NUITKA_MAY_BE_UNUSED static bool HAS_EXCEPTION_STATE(struct Nuitka_Excep...
function NUITKA_MAY_BE_UNUSED (line 984) | NUITKA_MAY_BE_UNUSED static bool
function NUITKA_MAY_BE_UNUSED (line 990) | NUITKA_MAY_BE_UNUSED inline static void
function NUITKA_MAY_BE_UNUSED (line 995) | NUITKA_MAY_BE_UNUSED inline static void
function NUITKA_MAY_BE_UNUSED (line 1002) | NUITKA_MAY_BE_UNUSED inline static void
function NUITKA_MAY_BE_UNUSED (line 1011) | NUITKA_MAY_BE_UNUSED static bool EXCEPTION_MATCH_GENERATOR(PyThreadState...
function NUITKA_MAY_BE_UNUSED (line 1055) | NUITKA_MAY_BE_UNUSED static bool EXCEPTION_MATCH_BOOL_SINGLE(PyThreadSta...
function NUITKA_MAY_BE_UNUSED (line 1090) | NUITKA_MAY_BE_UNUSED static inline int _EXCEPTION_MATCH_BOOL(PyThreadSta...
function NUITKA_MAY_BE_UNUSED (line 1143) | NUITKA_MAY_BE_UNUSED static inline int EXCEPTION_MATCH_BOOL(PyThreadStat...
function NUITKA_MAY_BE_UNUSED (line 1192) | NUITKA_MAY_BE_UNUSED static void FETCH_ERROR_OCCURRED(PyThreadState *tst...
function NUITKA_MAY_BE_UNUSED (line 1202) | NUITKA_MAY_BE_UNUSED static void RESTORE_ERROR_OCCURRED(PyThreadState *t...
FILE: nuitka/build/include/nuitka/helper/attributes.h
function hasTypeGenericGetAttr (line 52) | static inline bool hasTypeGenericGetAttr(PyTypeObject *type) {
function hasTypeGenericSetAttr (line 64) | static inline bool hasTypeGenericSetAttr(PyTypeObject *type) {
FILE: nuitka/build/include/nuitka/helper/boolean.h
function NUITKA_MAY_BE_UNUSED (line 11) | NUITKA_MAY_BE_UNUSED static int CHECK_IF_TRUE(PyObject *object) {
function NUITKA_MAY_BE_UNUSED (line 41) | NUITKA_MAY_BE_UNUSED static int CHECK_IF_FALSE(PyObject *object) {
function NUITKA_MAY_BE_UNUSED (line 53) | NUITKA_MAY_BE_UNUSED static inline PyObject *BOOL_FROM(bool value) {
type nuitka_bool (line 62) | typedef enum {
type nuitka_void (line 69) | typedef enum { NUITKA_VOID_OK = 0, NUITKA_VOID_EXCEPTION = 1 } nuitka_void;
FILE: nuitka/build/include/nuitka/helper/bytearrays.h
function NUITKA_MAY_BE_UNUSED (line 6) | NUITKA_MAY_BE_UNUSED static PyObject *BYTEARRAY_COPY(PyThreadState *tsta...
FILE: nuitka/build/include/nuitka/helper/complex.h
function NUITKA_MAY_BE_UNUSED (line 6) | NUITKA_MAY_BE_UNUSED static PyObject *BUILTIN_COMPLEX1(PyThreadState *ts...
function NUITKA_MAY_BE_UNUSED (line 15) | NUITKA_MAY_BE_UNUSED static PyObject *BUILTIN_COMPLEX2(PyThreadState *ts...
FILE: nuitka/build/include/nuitka/helper/dictionaries.h
function Py_ssize_t (line 6) | static inline Py_ssize_t DICT_SIZE(PyObject *dict) {
function PyDictObject (line 13) | static inline PyDictObject *MODULE_DICT(PyObject *module) {
type PyDictEntry (line 24) | typedef PyDictEntry *Nuitka_DictEntryHandle;
function PyDictEntry (line 26) | static PyDictEntry *GET_STRING_DICT_ENTRY(PyDictObject *dict, Nuitka_Str...
function NUITKA_MAY_BE_UNUSED (line 48) | NUITKA_MAY_BE_UNUSED static PyObject *GET_DICT_ENTRY_VALUE(Nuitka_DictEn...
function NUITKA_MAY_BE_UNUSED (line 50) | NUITKA_MAY_BE_UNUSED static void SET_DICT_ENTRY_VALUE(Nuitka_DictEntryHa...
function PyObject (line 54) | static PyObject *GET_STRING_DICT_VALUE(PyDictObject *dict, Nuitka_String...
type PyDictKeyEntry (line 65) | typedef struct {
type PyDictKeyEntry (line 74) | typedef PyDictKeyEntry *(*dict_lookup_func)(PyDictObject *mp, PyObject *...
type Py_ssize_t (line 76) | typedef Py_ssize_t (*dict_lookup_func)(PyDictObject *mp, PyObject *key, ...
type Py_ssize_t (line 79) | typedef Py_ssize_t (*dict_lookup_func)(PyDictObject *mp, PyObject *key, ...
type _dictkeysobject (line 87) | struct _dictkeysobject {
type PyObject (line 144) | typedef PyObject **Nuitka_DictEntryHandle;
function Nuitka_DictEntryHandle (line 151) | static Nuitka_DictEntryHandle GET_STRING_DICT_ENTRY(PyDictObject *dict, ...
function NUITKA_MAY_BE_UNUSED (line 209) | NUITKA_MAY_BE_UNUSED static PyObject *GET_DICT_ENTRY_VALUE(Nuitka_DictEn...
function NUITKA_MAY_BE_UNUSED (line 211) | NUITKA_MAY_BE_UNUSED static void SET_DICT_ENTRY_VALUE(Nuitka_DictEntryHa...
function NUITKA_MAY_BE_UNUSED (line 215) | NUITKA_MAY_BE_UNUSED static PyObject *GET_STRING_DICT_VALUE(PyDictObject...
function NUITKA_MAY_BE_UNUSED (line 229) | NUITKA_MAY_BE_UNUSED static bool DICT_SET_ITEM(PyObject *dict, PyObject ...
function NUITKA_MAY_BE_UNUSED (line 244) | NUITKA_MAY_BE_UNUSED static bool DICT_REMOVE_ITEM(PyObject *dict, PyObje...
function NUITKA_MAY_BE_UNUSED (line 271) | NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT0(PyDictObject *dict,...
function NUITKA_MAY_BE_UNUSED (line 299) | NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT_INPLACE(PyDictObject...
function NUITKA_MAY_BE_UNUSED (line 330) | NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT1(PyDictObject *dict,...
FILE: nuitka/build/include/nuitka/helper/indexes.h
function Nuitka_Index_Check (line 13) | static inline bool Nuitka_Index_Check(PyObject *obj) {
FILE: nuitka/build/include/nuitka/helper/ints.h
type nuitka_int_validity (line 6) | typedef enum {
type nuitka_int (line 13) | typedef struct {
type nuitka_long_validity (line 20) | typedef enum {
type nuitka_long (line 27) | typedef struct {
type nuitka_ilong_validity (line 35) | typedef enum {
type nuitka_ilong (line 42) | typedef struct {
function NUITKA_MAY_BE_UNUSED (line 49) | NUITKA_MAY_BE_UNUSED static void ENFORCE_ILONG_OBJECT_VALUE(nuitka_ilong...
function NUITKA_MAY_BE_UNUSED (line 77) | NUITKA_MAY_BE_UNUSED static inline PyObject *Nuitka_Long_GetSmallValue(i...
function NUITKA_MAY_BE_UNUSED (line 84) | NUITKA_MAY_BE_UNUSED static inline PyObject *Nuitka_Long_GetSmallValue(i...
FILE: nuitka/build/include/nuitka/helper/iterators.h
function NUITKA_MAY_BE_UNUSED (line 14) | NUITKA_MAY_BE_UNUSED static inline bool HAS_ITERNEXT(PyObject *value) {
type seqiterobject (line 36) | typedef struct {
function NUITKA_MAY_BE_UNUSED (line 46) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_ITERATOR_INFALLIBLE(PyObject ...
function NUITKA_MAY_BE_UNUSED (line 79) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_ITERATOR(PyThreadState *tstat...
function NUITKA_MAY_BE_UNUSED (line 130) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_UNPACK_ITERATOR(PyObject *ite...
function NUITKA_MAY_BE_UNUSED (line 169) | NUITKA_MAY_BE_UNUSED static PyObject *ITERATOR_NEXT(PyObject *iterator) {
function NUITKA_MAY_BE_UNUSED (line 197) | NUITKA_MAY_BE_UNUSED static PyObject *BUILTIN_NEXT2(PyThreadState *tstat...
function NUITKA_MAY_BE_UNUSED (line 220) | NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_INFALLIBLE(PyObject *i...
function NUITKA_MAY_BE_UNUSED (line 230) | NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate,...
function NUITKA_MAY_BE_UNUSED (line 272) | NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_STARRED(PyThreadState ...
function NUITKA_MAY_BE_UNUSED (line 297) | NUITKA_MAY_BE_UNUSED static bool UNPACK_ITERATOR_CHECK(PyThreadState *ts...
FILE: nuitka/build/include/nuitka/helper/lists.h
function NUITKA_MAY_BE_UNUSED (line 63) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_LIST_REPEATED(Py_ssize_t size...
FILE: nuitka/build/include/nuitka/helper/mappings.h
function NUITKA_MAY_BE_UNUSED (line 8) | NUITKA_MAY_BE_UNUSED static int MAPPING_HAS_ITEM(PyThreadState *tstate, ...
FILE: nuitka/build/include/nuitka/helper/operations.h
function NUITKA_MAY_BE_UNUSED (line 11) | NUITKA_MAY_BE_UNUSED static PyObject *UNICODE_CONCAT(PyThreadState *tsta...
type PyObject (line 29) | typedef PyObject *(unary_api)(PyObject *);
function NUITKA_MAY_BE_UNUSED (line 31) | NUITKA_MAY_BE_UNUSED static PyObject *UNARY_OPERATION(unary_api api, PyO...
FILE: nuitka/build/include/nuitka/helper/raising.h
function NUITKA_MAY_BE_UNUSED (line 7) | NUITKA_MAY_BE_UNUSED static void CHAIN_EXCEPTION(PyThreadState *tstate, ...
type Nuitka_ExceptionPreservationItem (line 77) | struct Nuitka_ExceptionPreservationItem
FILE: nuitka/build/include/nuitka/helper/rangeobjects.h
type _rangeobject3 (line 20) | struct _rangeobject3 {
function NUITKA_MAY_BE_UNUSED (line 30) | NUITKA_MAY_BE_UNUSED static PyObject *PyRange_Start(PyObject *range) { r...
function NUITKA_MAY_BE_UNUSED (line 32) | NUITKA_MAY_BE_UNUSED static PyObject *PyRange_Stop(PyObject *range) { re...
function NUITKA_MAY_BE_UNUSED (line 34) | NUITKA_MAY_BE_UNUSED static PyObject *PyRange_Step(PyObject *range) { re...
type _rangeobject2 (line 38) | struct _rangeobject2 {
FILE: nuitka/build/include/nuitka/helper/slices.h
function NUITKA_MAY_BE_UNUSED (line 13) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_SLICE_OBJECT3(PyObject *start...
function NUITKA_MAY_BE_UNUSED (line 20) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_SLICE_OBJECT2(PyObject *start...
function NUITKA_MAY_BE_UNUSED (line 26) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_SLICE_OBJECT1(PyObject *stop) {
function Py_ssize_t (line 45) | static Py_ssize_t CONVERT_TO_INDEX(PyThreadState *tstate, PyObject *valu...
function NUITKA_MAY_BE_UNUSED (line 59) | NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_SLICE(PyThreadState *tstate...
function NUITKA_MAY_BE_UNUSED (line 113) | NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_INDEX_SLICE(PyObject *sourc...
function NUITKA_MAY_BE_UNUSED (line 125) | NUITKA_MAY_BE_UNUSED static bool SET_SLICE(PyThreadState *tstate, PyObje...
function NUITKA_MAY_BE_UNUSED (line 178) | NUITKA_MAY_BE_UNUSED static bool SET_INDEX_SLICE(PyObject *target, Py_ss...
function NUITKA_MAY_BE_UNUSED (line 210) | NUITKA_MAY_BE_UNUSED static bool DEL_SLICE(PyThreadState *tstate, PyObje...
function NUITKA_MAY_BE_UNUSED (line 261) | NUITKA_MAY_BE_UNUSED static bool DEL_INDEX_SLICE(PyObject *target, Py_ss...
FILE: nuitka/build/include/nuitka/helper/subscripts.h
function formatNotSubscriptableTypeError (line 9) | static void formatNotSubscriptableTypeError(PyObject *type) {
function PyObject (line 38) | static PyObject *SEQUENCE_GET_ITEM_CONST(PyObject *sequence, Py_ssize_t ...
function NUITKA_MAY_BE_UNUSED (line 65) | NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_SUBSCRIPT_CONST(PyThreadSta...
function NUITKA_MAY_BE_UNUSED (line 180) | NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_SUBSCRIPT(PyThreadState *ts...
function NUITKA_MAY_BE_UNUSED (line 241) | NUITKA_MAY_BE_UNUSED static bool HAS_SUBSCRIPT_CONST(PyThreadState *tsta...
function NUITKA_MAY_BE_UNUSED (line 358) | NUITKA_MAY_BE_UNUSED static bool HAS_SUBSCRIPT(PyThreadState *tstate, Py...
function NUITKA_MAY_BE_UNUSED (line 426) | NUITKA_MAY_BE_UNUSED static bool SET_SUBSCRIPT_CONST(PyThreadState *tsta...
function NUITKA_MAY_BE_UNUSED (line 497) | NUITKA_MAY_BE_UNUSED static bool SET_SUBSCRIPT(PyThreadState *tstate, Py...
function NUITKA_MAY_BE_UNUSED (line 545) | NUITKA_MAY_BE_UNUSED static bool DEL_SUBSCRIPT(PyObject *target, PyObjec...
FILE: nuitka/build/include/nuitka/helper/tuples.h
function NUITKA_MAY_BE_UNUSED (line 25) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE(PyObject *const *elemen...
function NUITKA_MAY_BE_UNUSED (line 35) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE1(PyObject *element1) {
function NUITKA_MAY_BE_UNUSED (line 43) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE1_0(PyObject *element1) {
function NUITKA_MAY_BE_UNUSED (line 51) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE2(PyObject *element1, Py...
function NUITKA_MAY_BE_UNUSED (line 60) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE2_0(PyObject *element1, ...
function NUITKA_MAY_BE_UNUSED (line 69) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE3(PyObject *element1, Py...
function NUITKA_MAY_BE_UNUSED (line 79) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE3_0(PyObject *element1, ...
function NUITKA_MAY_BE_UNUSED (line 89) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE4(PyObject *element1, Py...
function NUITKA_MAY_BE_UNUSED (line 101) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE4_0(PyObject *element1, ...
function NUITKA_MAY_BE_UNUSED (line 113) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE5(PyObject *element1, Py...
function NUITKA_MAY_BE_UNUSED (line 126) | NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE5_0(PyObject *element1, ...
FILE: nuitka/build/include/nuitka/helpers.h
type PyModuleObject (line 52) | typedef struct {
function NUITKA_MAY_BE_UNUSED (line 106) | NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_VARS(PyThreadState *tstate,...
function NUITKA_MAY_BE_UNUSED (line 348) | NUITKA_MAY_BE_UNUSED static PyObject *MODULE_NAME1(PyThreadState *tstate...
function NUITKA_MAY_BE_UNUSED (line 355) | NUITKA_MAY_BE_UNUSED static PyObject *MODULE_NAME0(PyThreadState *tstate...
function NUITKA_MAY_BE_UNUSED (line 404) | NUITKA_MAY_BE_UNUSED static void forceGC(void) {
FILE: nuitka/build/include/nuitka/importing.h
function NUITKA_MAY_BE_UNUSED (line 48) | NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_GetSysModules(void) {
function NUITKA_MAY_BE_UNUSED (line 59) | NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_GetModule(PyThreadState *ts...
function NUITKA_MAY_BE_UNUSED (line 64) | NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_GetModuleString(PyThreadSta...
function NUITKA_MAY_BE_UNUSED (line 73) | NUITKA_MAY_BE_UNUSED static bool Nuitka_SetModule(PyObject *module_name,...
function NUITKA_MAY_BE_UNUSED (line 82) | NUITKA_MAY_BE_UNUSED static bool Nuitka_SetModuleString(char const *modu...
function NUITKA_MAY_BE_UNUSED (line 91) | NUITKA_MAY_BE_UNUSED static bool Nuitka_DelModule(PyThreadState *tstate,...
function NUITKA_MAY_BE_UNUSED (line 105) | NUITKA_MAY_BE_UNUSED static bool Nuitka_DelModuleString(PyThreadState *t...
function NUITKA_MAY_BE_UNUSED (line 114) | NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_GetFilenameObject(PyThreadS...
FILE: nuitka/build/include/nuitka/prelude.h
function Nuitka_static_builtin_index_get (line 106) | static inline size_t Nuitka_static_builtin_index_get(PyTypeObject *self)...
function static_builtin_state (line 108) | static inline static_builtin_state *Nuitka_static_builtin_state_get(PyIn...
function NUITKA_MAY_BE_UNUSED (line 112) | NUITKA_MAY_BE_UNUSED static inline static_builtin_state *Nuitka_PyStatic...
function NUITKA_MAY_BE_UNUSED (line 258) | NUITKA_MAY_BE_UNUSED static inline bool Nuitka_StringOrUnicode_CheckExac...
function NUITKA_MAY_BE_UNUSED (line 295) | NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_TypeLookup(PyTypeObject *ty...
type Py_hash_t (line 329) | typedef long Py_hash_t;
type sdigit (line 438) | typedef signed int sdigit;
type nuitka_digit (line 443) | typedef long nuitka_digit;
FILE: nuitka/build/include/nuitka/safe_string_ops.h
type DWORD (line 27) | typedef DWORD error_code_t;
function error_code_t (line 29) | static inline error_code_t getCurrentErrorCode(void) { return GetLastErr...
type error_code_t (line 31) | typedef int error_code_t;
function error_code_t (line 33) | static inline error_code_t getCurrentErrorCode(void) { return errno; }
FILE: nuitka/build/include/nuitka/threading.h
type _ceval_runtime_state (line 31) | struct _ceval_runtime_state
type _ceval_state (line 33) | struct _ceval_state
type _ceval_runtime_state (line 35) | struct _ceval_runtime_state
function NUITKA_MAY_BE_UNUSED (line 76) | NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState...
FILE: nuitka/build/include/nuitka/tracing.h
function PRINT_TIME_STAMP (line 35) | static void inline PRINT_TIME_STAMP(void) {
function PRINT_TIME_STAMP (line 41) | static void inline PRINT_TIME_STAMP(void) {
FILE: nuitka/build/include/nuitka/unfreezing.h
type Nuitka_MetaPathBasedLoaderEntry (line 19) | struct Nuitka_MetaPathBasedLoaderEntry
type PyObject (line 21) | typedef PyObject *(*module_initfunc)(PyThreadState *tstate, PyObject *mo...
type Nuitka_MetaPathBasedLoaderEntry (line 29) | struct Nuitka_MetaPathBasedLoaderEntry {
type Nuitka_MetaPathBasedLoaderEntry (line 58) | struct Nuitka_MetaPathBasedLoaderEntry
type Nuitka_MetaPathBasedLoaderEntry (line 62) | struct Nuitka_MetaPathBasedLoaderEntry
FILE: nuitka/build/inline_copy/appdirs/appdirs.py
function user_data_dir (line 45) | def user_data_dir(appname=None, appauthor=None, version=None, roaming=Fa...
function site_data_dir (line 100) | def site_data_dir(appname=None, appauthor=None, version=None, multipath=...
function user_config_dir (line 166) | def user_config_dir(appname=None, appauthor=None, version=None, roaming=...
function site_config_dir (line 206) | def site_config_dir(appname=None, appauthor=None, version=None, multipat...
function user_cache_dir (line 257) | def user_cache_dir(appname=None, appauthor=None, version=None, opinion=T...
function user_state_dir (line 314) | def user_state_dir(appname=None, appauthor=None, version=None, roaming=F...
function user_log_dir (line 356) | def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
class AppDirs (line 407) | class AppDirs(object):
method __init__ (line 409) | def __init__(self, appname=None, appauthor=None, version=None,
method user_data_dir (line 418) | def user_data_dir(self):
method site_data_dir (line 423) | def site_data_dir(self):
method user_config_dir (line 428) | def user_config_dir(self):
method site_config_dir (line 433) | def site_config_dir(self):
method user_cache_dir (line 438) | def user_cache_dir(self):
method user_state_dir (line 443) | def user_state_dir(self):
method user_log_dir (line 448) | def user_log_dir(self):
function _get_win_folder_from_registry (line 455) | def _get_win_folder_from_registry(csidl_name):
function _get_win_folder_with_pywin32 (line 479) | def _get_win_folder_with_pywin32(csidl_name):
function _get_win_folder_with_ctypes (line 506) | def _get_win_folder_with_ctypes(csidl_name):
function _get_win_folder_with_jna (line 532) | def _get_win_folder_with_jna(csidl_name):
FILE: nuitka/build/inline_copy/atomicwrites/atomicwrites.py
function _path_to_unicode (line 26) | def _path_to_unicode(x):
function _proper_fsync (line 40) | def _proper_fsync(fd):
function _sync_directory (line 46) | def _sync_directory(directory):
function _replace_atomic (line 54) | def _replace_atomic(src, dst):
function _move_atomic (line 58) | def _move_atomic(src, dst):
function _handle_errors (line 74) | def _handle_errors(rv):
function _replace_atomic (line 78) | def _replace_atomic(src, dst):
function _move_atomic (line 84) | def _move_atomic(src, dst):
function replace_atomic (line 91) | def replace_atomic(src, dst):
function move_atomic (line 102) | def move_atomic(src, dst):
class AtomicWriter (line 114) | class AtomicWriter(object):
method __init__ (line 132) | def __init__(self, path, mode=DEFAULT_MODE, overwrite=False,
method open (line 155) | def open(self):
method _open (line 162) | def _open(self, get_fileobject):
method get_fileobject (line 178) | def get_fileobject(self, suffix="", prefix=tempfile.gettempprefix(),
method sync (line 193) | def sync(self, f):
method commit (line 199) | def commit(self, f):
method rollback (line 206) | def rollback(self, f):
function atomic_write (line 211) | def atomic_write(path, writer_cls=AtomicWriter, **cls_kwargs):
FILE: nuitka/build/inline_copy/bin/scons.py
function md5 (line 49) | def md5(value=b""):
FILE: nuitka/build/inline_copy/clcache/clcache/caching.py
function printBinary (line 93) | def printBinary(stream, rawData):
function basenameWithoutExtension (line 99) | def basenameWithoutExtension(path):
function filesBeneath (line 104) | def filesBeneath(baseDir):
function childDirectories (line 110) | def childDirectories(path, absolute=True):
function normalizeBaseDir (line 122) | def normalizeBaseDir(baseDir):
function getCachedCompilerConsoleOutput (line 133) | def getCachedCompilerConsoleOutput(path):
function setCachedCompilerConsoleOutput (line 141) | def setCachedCompilerConsoleOutput(path, output):
class IncludeNotFoundException (line 146) | class IncludeNotFoundException(Exception):
class CacheLockException (line 150) | class CacheLockException(Exception):
class CompilerFailedException (line 154) | class CompilerFailedException(Exception):
method __init__ (line 155) | def __init__(self, exitCode, msgErr, msgOut=""):
method getReturnTuple (line 161) | def getReturnTuple(self):
class Manifest (line 165) | class Manifest(object):
method __init__ (line 166) | def __init__(self, entries=None):
method entries (line 171) | def entries(self):
method addEntry (line 174) | def addEntry(self, entry):
method touchEntry (line 178) | def touchEntry(self, objectHash):
class ManifestSection (line 186) | class ManifestSection(object):
method __init__ (line 187) | def __init__(self, manifestSectionDir):
method manifestPath (line 191) | def manifestPath(self, manifestHash):
method manifestFiles (line 194) | def manifestFiles(self):
method setManifest (line 197) | def setManifest(self, manifestHash, manifest):
method getManifest (line 211) | def getManifest(self, manifestHash):
function allSectionsLocked (line 234) | def allSectionsLocked(repository):
class ManifestRepository (line 245) | class ManifestRepository(object):
method __init__ (line 253) | def __init__(self, manifestsRootDir):
method section (line 256) | def section(self, manifestHash):
method sections (line 259) | def sections(self):
method clean (line 264) | def clean(self, maxManifestsSize):
method getManifestHash (line 284) | def getManifestHash(compilerBinary, commandLine, sourceFile):
method getIncludesContentHashForFiles (line 319) | def getIncludesContentHashForFiles(includes):
method getIncludesContentHashForHashes (line 327) | def getIncludesContentHashForHashes(listOfHashes):
class CacheLock2 (line 336) | class CacheLock2(object):
method __init__ (line 339) | def __init__(self):
method __enter__ (line 342) | def __enter__(self):
method __exit__ (line 345) | def __exit__(self, typ, value, traceback):
method forPath (line 349) | def forPath(path):
class CacheLock (line 352) | class CacheLock(object):
method __init__ (line 360) | def __init__(self, mutexName, timeoutMs):
method createMutex (line 365) | def createMutex(self):
method __enter__ (line 372) | def __enter__(self):
method __exit__ (line 375) | def __exit__(self, typ, value, traceback):
method __del__ (line 378) | def __del__(self):
method acquire (line 382) | def acquire(self):
method release (line 407) | def release(self):
method forPath (line 411) | def forPath(path):
class CompilerArtifactsSection (line 417) | class CompilerArtifactsSection(object):
method __init__ (line 422) | def __init__(self, compilerArtifactsSectionDir):
method cacheEntryDir (line 426) | def cacheEntryDir(self, key):
method cacheEntries (line 429) | def cacheEntries(self):
method cachedObjectName (line 432) | def cachedObjectName(self, key):
method hasEntry (line 437) | def hasEntry(self, key):
method setEntry (line 440) | def setEntry(self, key, artifacts):
method getEntry (line 474) | def getEntry(self, key):
class CompilerArtifactsRepository (line 488) | class CompilerArtifactsRepository(object):
method __init__ (line 489) | def __init__(self, compilerArtifactsRootDir):
method section (line 492) | def section(self, key):
method sections (line 497) | def sections(self):
method removeEntry (line 503) | def removeEntry(self, keyToBeRemoved):
method clean (line 509) | def clean(self, maxCompilerArtifactsSize):
method computeKeyDirect (line 535) | def computeKeyDirect(manifestHash, includesContentHash):
method computeKeyNodirect (line 542) | def computeKeyNodirect(compilerBinary, commandLine, environment):
method _normalizedCommandLine (line 572) | def _normalizedCommandLine(cmdline):
class CacheFileStrategy (line 610) | class CacheFileStrategy(object):
method __init__ (line 611) | def __init__(self, cacheDirectory=None):
method __str__ (line 636) | def __str__(self):
method lock (line 641) | def lock(self):
method lockFor (line 647) | def lockFor(self, key):
method manifestLockFor (line 651) | def manifestLockFor(self, key):
method getEntry (line 654) | def getEntry(self, key):
method setEntry (line 657) | def setEntry(self, key, value):
method pathForObject (line 660) | def pathForObject(self, key):
method directoryForCache (line 663) | def directoryForCache(self, key):
method deserializeCacheEntry (line 666) | def deserializeCacheEntry(self, key, objectData):
method hasEntry (line 673) | def hasEntry(self, cachekey):
method setManifest (line 676) | def setManifest(self, manifestHash, manifest):
method getManifest (line 681) | def getManifest(self, manifestHash):
method clean (line 684) | def clean(self, stats, maximumSize):
class Cache (line 714) | class Cache(object):
method __init__ (line 715) | def __init__(self, cacheDirectory=None):
method __str__ (line 725) | def __str__(self):
method lock (line 729) | def lock(self):
method manifestLockFor (line 733) | def manifestLockFor(self, key):
method configuration (line 738) | def configuration(self):
method statistics (line 742) | def statistics(self):
method clean (line 745) | def clean(self, stats, maximumSize):
method lockFor (line 749) | def lockFor(self, key):
method getEntry (line 753) | def getEntry(self, key):
method setEntry (line 756) | def setEntry(self, key, value):
method hasEntry (line 759) | def hasEntry(self, cachekey):
method setManifest (line 762) | def setManifest(self, manifestHash, manifest):
method getManifest (line 765) | def getManifest(self, manifestHash):
class PersistentJSONDict (line 769) | class PersistentJSONDict(object):
method __init__ (line 770) | def __init__(self, fileName):
method save (line 782) | def save(self):
method __setitem__ (line 787) | def __setitem__(self, key, value):
method __getitem__ (line 791) | def __getitem__(self, key):
method __contains__ (line 794) | def __contains__(self, key):
method __eq__ (line 797) | def __eq__(self, other):
class Configuration (line 801) | class Configuration(object):
method __init__ (line 804) | def __init__(self, configurationFile):
method __enter__ (line 808) | def __enter__(self):
method __exit__ (line 815) | def __exit__(self, typ, value, traceback):
method maximumCacheSize (line 819) | def maximumCacheSize(self):
method setMaximumCacheSize (line 822) | def setMaximumCacheSize(self, size):
class Statistics (line 827) | class Statistics(object):
method __init__ (line 862) | def __init__(self, statsFile):
method __enter__ (line 871) | def __enter__(self):
method __exit__ (line 877) | def __exit__(self, typ, value, traceback):
method __eq__ (line 883) | def __eq__(self, other):
method numCallsWithInvalidArgument (line 886) | def numCallsWithInvalidArgument(self):
method registerCallWithInvalidArgument (line 889) | def registerCallWithInvalidArgument(self):
method numCallsWithoutSourceFile (line 892) | def numCallsWithoutSourceFile(self):
method registerCallWithoutSourceFile (line 895) | def registerCallWithoutSourceFile(self):
method numCallsWithMultipleSourceFiles (line 898) | def numCallsWithMultipleSourceFiles(self):
method registerCallWithMultipleSourceFiles (line 901) | def registerCallWithMultipleSourceFiles(self):
method numCallsWithPch (line 904) | def numCallsWithPch(self):
method registerCallWithPch (line 907) | def registerCallWithPch(self):
method numCallsForLinking (line 910) | def numCallsForLinking(self):
method registerCallForLinking (line 913) | def registerCallForLinking(self):
method numCallsForExternalDebugInfo (line 916) | def numCallsForExternalDebugInfo(self):
method registerCallForExternalDebugInfo (line 919) | def registerCallForExternalDebugInfo(self):
method numEvictedMisses (line 922) | def numEvictedMisses(self):
method registerEvictedMiss (line 925) | def registerEvictedMiss(self):
method numHeaderChangedMisses (line 929) | def numHeaderChangedMisses(self):
method registerHeaderChangedMiss (line 932) | def registerHeaderChangedMiss(self):
method numSourceChangedMisses (line 936) | def numSourceChangedMisses(self):
method registerSourceChangedMiss (line 939) | def registerSourceChangedMiss(self):
method numCacheEntries (line 943) | def numCacheEntries(self):
method setNumCacheEntries (line 946) | def setNumCacheEntries(self, number):
method registerCacheEntry (line 949) | def registerCacheEntry(self, size):
method unregisterCacheEntry (line 953) | def unregisterCacheEntry(self, size):
method currentCacheSize (line 957) | def currentCacheSize(self):
method setCacheSize (line 960) | def setCacheSize(self, size):
method numCacheHits (line 963) | def numCacheHits(self):
method registerCacheHit (line 966) | def registerCacheHit(self):
method numCacheMisses (line 969) | def numCacheMisses(self):
method registerCacheMiss (line 972) | def registerCacheMiss(self):
method numCallsForPreprocessing (line 975) | def numCallsForPreprocessing(self):
method registerCallForPreprocessing (line 978) | def registerCallForPreprocessing(self):
method resetCounters (line 981) | def resetCounters(self):
class AnalysisError (line 986) | class AnalysisError(Exception):
class NoSourceFileError (line 990) | class NoSourceFileError(AnalysisError):
class MultipleSourceFilesComplexError (line 994) | class MultipleSourceFilesComplexError(AnalysisError):
class CalledForLinkError (line 998) | class CalledForLinkError(AnalysisError):
class CalledWithPchError (line 1002) | class CalledWithPchError(AnalysisError):
class ExternalDebugInfoError (line 1006) | class ExternalDebugInfoError(AnalysisError):
class CalledForPreprocessingError (line 1010) | class CalledForPreprocessingError(AnalysisError):
class InvalidArgumentError (line 1014) | class InvalidArgumentError(AnalysisError):
function getCompilerHash (line 1018) | def getCompilerHash(compilerBinary):
function getFileHashes (line 1032) | def getFileHashes(filePaths):
function getFileHash (line 1058) | def getFileHash(filePath, additionalData=None):
function getStringHash (line 1077) | def getStringHash(dataString):
function expandBasedirPlaceholder (line 1083) | def expandBasedirPlaceholder(path):
function collapseBasedirToPlaceholder (line 1097) | def collapseBasedirToPlaceholder(path):
function ensureDirectoryExists (line 1110) | def ensureDirectoryExists(path):
function copyOrLink (line 1118) | def copyOrLink(srcFilePath, dstFilePath, writeCache=False):
function printTraceStatement (line 1159) | def printTraceStatement(msg):
class CommandLineTokenizer (line 1166) | class CommandLineTokenizer(object):
method __init__ (line 1167) | def __init__(self, content):
method _initialState (line 1181) | def _initialState(self, currentChar):
method _unquotedState (line 1195) | def _unquotedState(self, currentChar):
method _quotedState (line 1211) | def _quotedState(self, currentChar):
method _parseBackslash (line 1222) | def _parseBackslash(self):
function splitCommandsFile (line 1242) | def splitCommandsFile(content):
function expandCommandLine (line 1246) | def expandCommandLine(cmdline):
function extendCommandLineFromEnvironment (line 1284) | def extendCommandLineFromEnvironment(cmdLine, environment):
class Argument (line 1298) | class Argument(object):
method __init__ (line 1299) | def __init__(self, name):
method __len__ (line 1302) | def __len__(self):
method __str__ (line 1305) | def __str__(self):
method __eq__ (line 1308) | def __eq__(self, other):
method __hash__ (line 1311) | def __hash__(self):
class ArgumentT1 (line 1317) | class ArgumentT1(Argument):
class ArgumentT2 (line 1322) | class ArgumentT2(Argument):
class ArgumentT3 (line 1327) | class ArgumentT3(Argument):
class ArgumentT4 (line 1332) | class ArgumentT4(Argument):
class CommandLineAnalyzer (line 1336) | class CommandLineAnalyzer(object):
method _getParameterizedArgumentType (line 1385) | def _getParameterizedArgumentType(cmdLineArgument):
method parseArgumentsAndInputFiles (line 1393) | def parseArgumentsAndInputFiles(cmdline):
method analyze (line 1445) | def analyze(cmdline):
function invokeRealCompiler (line 1502) | def invokeRealCompiler(
function jobCount (line 1545) | def jobCount(cmdLine):
function printStatistics (line 1565) | def printStatistics(cache):
function resetStatistics (line 1610) | def resetStatistics(cache):
function cleanCache (line 1615) | def cleanCache(cache):
function clearCache (line 1620) | def clearCache(cache):
function parseIncludesSet (line 1630) | def parseIncludesSet(compilerOutput, sourceFile, strip):
function addObjectToCache (line 1664) | def addObjectToCache(stats, cache, cachekey, artifacts):
function processCacheHit (line 1682) | def processCacheHit(cache, objectFile, cachekey):
function createManifestEntry (line 1702) | def createManifestEntry(manifestHash, includePaths):
function run (line 1717) | def run(cache, compiler, compiler_args, env):
function runClCache (line 1730) | def runClCache(compiler, compiler_args, env):
function updateCacheStatistics (line 1746) | def updateCacheStatistics(cache, method):
function printOutAndErr (line 1751) | def printOutAndErr(out, err):
function printErrStr (line 1757) | def printErrStr(message):
function processCompileRequest (line 1762) | def processCompileRequest(cache, compiler, args, env):
function filterSourceFiles (line 1817) | def filterSourceFiles(
function scheduleJobs (line 1829) | def scheduleJobs(
function processSingleSource (line 1883) | def processSingleSource(compiler, cmdLine, sourceFile, objectFile, envir...
function processDirect (line 1901) | def processDirect(cache, objectFile, compiler, cmdLine, sourceFile, env):
function processNoDirect (line 1978) | def processNoDirect(cache, objectFile, compiler, cmdLine, environment):
function ensureArtifactsExist (line 1995) | def ensureArtifactsExist(
FILE: nuitka/build/inline_copy/colorama/colorama/ansi.py
function code_to_chars (line 12) | def code_to_chars(code):
function set_title (line 15) | def set_title(title):
function clear_screen (line 18) | def clear_screen(mode=2):
function clear_line (line 21) | def clear_line(mode=2):
class AnsiCodes (line 25) | class AnsiCodes(object):
method __init__ (line 26) | def __init__(self):
class AnsiCursor (line 36) | class AnsiCursor(object):
method UP (line 37) | def UP(self, n=1):
method DOWN (line 39) | def DOWN(self, n=1):
method FORWARD (line 41) | def FORWARD(self, n=1):
method BACK (line 43) | def BACK(self, n=1):
method POS (line 45) | def POS(self, x=1, y=1):
class AnsiFore (line 49) | class AnsiFore(AnsiCodes):
class AnsiBack (line 71) | class AnsiBack(AnsiCodes):
class AnsiStyle (line 93) | class AnsiStyle(AnsiCodes):
FILE: nuitka/build/inline_copy/colorama/colorama/ansitowin32.py
class StreamWrapper (line 16) | class StreamWrapper(object):
method __init__ (line 22) | def __init__(self, wrapped, converter):
method __getattr__ (line 28) | def __getattr__(self, name):
method __enter__ (line 31) | def __enter__(self, *args, **kwargs):
method __exit__ (line 37) | def __exit__(self, *args, **kwargs):
method write (line 40) | def write(self, text):
method isatty (line 43) | def isatty(self):
method closed (line 56) | def closed(self):
class AnsiToWin32 (line 64) | class AnsiToWin32(object):
method __init__ (line 73) | def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
method should_wrap (line 106) | def should_wrap(self):
method get_win32_calls (line 116) | def get_win32_calls(self):
method write (line 160) | def write(self, text):
method reset_all (line 170) | def reset_all(self):
method write_and_convert (line 177) | def write_and_convert(self, text):
method write_plain_text (line 193) | def write_plain_text(self, text, start, end):
method convert_ansi (line 199) | def convert_ansi(self, paramstring, command):
method extract_params (line 205) | def extract_params(self, command, paramstring):
method call_win32 (line 223) | def call_win32(self, command, params):
method convert_osc (line 245) | def convert_osc(self, text):
FILE: nuitka/build/inline_copy/colorama/colorama/initialise.py
function reset_all (line 18) | def reset_all():
function init (line 23) | def init(autoreset=False, convert=None, strip=None, wrap=True):
function deinit (line 51) | def deinit():
function colorama_text (line 59) | def colorama_text(*args, **kwargs):
function reinit (line 67) | def reinit():
function wrap_stream (line 74) | def wrap_stream(stream, convert, strip, autoreset, wrap):
FILE: nuitka/build/inline_copy/colorama/colorama/win32.py
class CONSOLE_SCREEN_BUFFER_INFO (line 21) | class CONSOLE_SCREEN_BUFFER_INFO(Structure):
method __str__ (line 30) | def __str__(self):
function _winapi_test (line 92) | def _winapi_test(handle):
function winapi_test (line 98) | def winapi_test():
function GetConsoleScreenBufferInfo (line 102) | def GetConsoleScreenBufferInfo(stream_id=STDOUT):
function SetConsoleTextAttribute (line 109) | def SetConsoleTextAttribute(stream_id, attrs):
function SetConsoleCursorPosition (line 113) | def SetConsoleCursorPosition(stream_id, position, adjust=True):
function FillConsoleOutputCharacter (line 131) | def FillConsoleOutputCharacter(stream_id, char, length, start):
function FillConsoleOutputAttribute (line 141) | def FillConsoleOutputAttribute(stream_id, attr, length, start):
function SetConsoleTitle (line 151) | def SetConsoleTitle(title):
FILE: nuitka/build/inline_copy/colorama/colorama/winterm.py
class WinColor (line 6) | class WinColor(object):
class WinStyle (line 17) | class WinStyle(object):
class WinTerm (line 22) | class WinTerm(object):
method __init__ (line 24) | def __init__(self):
method get_attrs (line 36) | def get_attrs(self):
method set_attrs (line 39) | def set_attrs(self, value):
method reset_all (line 44) | def reset_all(self, on_stderr=None):
method fore (line 49) | def fore(self, fore=None, light=False, on_stderr=False):
method back (line 60) | def back(self, back=None, light=False, on_stderr=False):
method style (line 71) | def style(self, style=None, on_stderr=False):
method set_console (line 77) | def set_console(self, attrs=None, on_stderr=False):
method get_position (line 85) | def get_position(self, handle):
method set_cursor_position (line 93) | def set_cursor_position(self, position=None, on_stderr=False):
method cursor_adjust (line 103) | def cursor_adjust(self, x, y, on_stderr=False):
method erase_screen (line 111) | def erase_screen(self, mode=0, on_stderr=False):
method erase_line (line 143) | def erase_line(self, mode=0, on_stderr=False):
method set_title (line 168) | def set_title(self, title):
FILE: nuitka/build/inline_copy/glob2/glob2/compat.py
class _HashedSeq (line 10) | class _HashedSeq(list):
method __init__ (line 13) | def __init__(self, tup, hash=hash):
method __hash__ (line 17) | def __hash__(self):
function _make_key (line 20) | def _make_key(args, kwds, typed,
function lru_cache (line 39) | def lru_cache(maxsize=100, typed=False):
FILE: nuitka/build/inline_copy/glob2/glob2/fnmatch.py
function _norm_paths (line 22) | def _norm_paths(path, norm_paths, sep):
function fnmatch (line 30) | def fnmatch(name, pat, norm_paths=True, case_sensitive=True, sep=None):
function _compile_pattern (line 72) | def _compile_pattern(pat, case_sensitive):
function filter (line 83) | def filter(names, pat, norm_paths=True, case_sensitive=True, sep=None):
function fnmatchcase (line 96) | def fnmatchcase(name, pat, case_sensitive=True):
function translate (line 106) | def translate(pat):
FILE: nuitka/build/inline_copy/glob2/glob2/impl.py
class Globber (line 17) | class Globber(object):
method walk (line 24) | def walk(self, top, followlinks=False, sep=None):
method glob (line 48) | def glob(self, pathname, with_matches=False, include_hidden=False, rec...
method iglob (line 63) | def iglob(self, pathname, with_matches=False, include_hidden=False, re...
method _iglob (line 87) | def _iglob(self, pathname, rootcall, include_hidden,
method resolve_pattern (line 132) | def resolve_pattern(self, dirname, pattern, globstar_with_root, includ...
function has_magic (line 199) | def has_magic(s):
function _ishidden (line 207) | def _ishidden(path):
function _join_paths (line 211) | def _join_paths(paths, sep=None):
FILE: nuitka/build/inline_copy/jinja2/jinja2/_compat.py
function reraise (line 35) | def reraise(tp, value, tb=None):
function implements_iterator (line 69) | def implements_iterator(cls):
function implements_to_string (line 74) | def implements_to_string(cls):
function encode_filename (line 79) | def encode_filename(filename):
function with_metaclass (line 85) | def with_metaclass(meta, *bases):
FILE: nuitka/build/inline_copy/jinja2/jinja2/bccache.py
function marshal_dump (line 36) | def marshal_dump(code, f):
function marshal_load (line 42) | def marshal_load(f):
class Bucket (line 60) | class Bucket(object):
method __init__ (line 69) | def __init__(self, environment, key, checksum):
method reset (line 75) | def reset(self):
method load_bytecode (line 79) | def load_bytecode(self, f):
method write_bytecode (line 98) | def write_bytecode(self, f):
method bytecode_from_string (line 106) | def bytecode_from_string(self, string):
method bytecode_to_string (line 110) | def bytecode_to_string(self):
class BytecodeCache (line 117) | class BytecodeCache(object):
method load_bytecode (line 146) | def load_bytecode(self, bucket):
method dump_bytecode (line 153) | def dump_bytecode(self, bucket):
method clear (line 160) | def clear(self):
method get_cache_key (line 166) | def get_cache_key(self, name, filename=None):
method get_source_checksum (line 176) | def get_source_checksum(self, source):
method get_bucket (line 180) | def get_bucket(self, environment, name, filename, source):
method set_bucket (line 190) | def set_bucket(self, bucket):
class FileSystemBytecodeCache (line 195) | class FileSystemBytecodeCache(BytecodeCache):
method __init__ (line 213) | def __init__(self, directory=None, pattern='__jinja2_%s.cache'):
method _get_default_cache_dir (line 219) | def _get_default_cache_dir(self):
method _get_cache_filename (line 260) | def _get_cache_filename(self, bucket):
method load_bytecode (line 263) | def load_bytecode(self, bucket):
method dump_bytecode (line 271) | def dump_bytecode(self, bucket):
method clear (line 278) | def clear(self):
class MemcachedBytecodeCache (line 291) | class MemcachedBytecodeCache(BytecodeCache):
method __init__ (line 336) | def __init__(self, client, prefix='jinja2/bytecode/', timeout=None,
method load_bytecode (line 343) | def load_bytecode(self, bucket):
method dump_bytecode (line 353) | def dump_bytecode(self, bucket):
FILE: nuitka/build/inline_copy/jinja2/jinja2/compiler.py
function optimizeconst (line 63) | def optimizeconst(f):
function generate (line 74) | def generate(node, environment, name, filename, stream=None,
function has_safe_repr (line 87) | def has_safe_repr(value):
function find_undeclared (line 108) | def find_undeclared(nodes, names):
class MacroRef (line 121) | class MacroRef(object):
method __init__ (line 123) | def __init__(self, node):
class Frame (line 130) | class Frame(object):
method __init__ (line 133) | def __init__(self, eval_ctx, parent=None, level=None):
method copy (line 165) | def copy(self):
method inner (line 172) | def inner(self, isolated=False):
method soft (line 178) | def soft(self):
class VisitorExit (line 192) | class VisitorExit(RuntimeError):
class DependencyFinderVisitor (line 196) | class DependencyFinderVisitor(NodeVisitor):
method __init__ (line 199) | def __init__(self):
method visit_Filter (line 203) | def visit_Filter(self, node):
method visit_Test (line 207) | def visit_Test(self, node):
method visit_Block (line 211) | def visit_Block(self, node):
class UndeclaredNameVisitor (line 215) | class UndeclaredNameVisitor(NodeVisitor):
method __init__ (line 221) | def __init__(self, names):
method visit_Name (line 225) | def visit_Name(self, node):
method visit_Block (line 233) | def visit_Block(self, node):
class CompilerExit (line 237) | class CompilerExit(Exception):
class CodeGenerator (line 244) | class CodeGenerator(NodeVisitor):
method __init__ (line 246) | def __init__(self, environment, name, filename, stream=None,
method fail (line 313) | def fail(self, msg, lineno):
method temporary_identifier (line 317) | def temporary_identifier(self):
method buffer (line 322) | def buffer(self, frame):
method return_buffer_contents (line 327) | def return_buffer_contents(self, frame, force_unescaped=False):
method indent (line 345) | def indent(self):
method outdent (line 349) | def outdent(self, step=1):
method start_write (line 353) | def start_write(self, frame, node=None):
method end_write (line 360) | def end_write(self, frame):
method simple_write (line 365) | def simple_write(self, s, frame, node=None):
method blockvisit (line 371) | def blockvisit(self, nodes, frame):
method write (line 382) | def write(self, x):
method writeline (line 397) | def writeline(self, x, node=None, extra=0):
method newline (line 402) | def newline(self, node=None, extra=0):
method signature (line 409) | def signature(self, node, frame, extra_kwargs=None):
method pull_dependencies (line 462) | def pull_dependencies(self, nodes):
method enter_frame (line 475) | def enter_frame(self, frame):
method leave_frame (line 492) | def leave_frame(self, frame, with_python_scope=False):
method func (line 500) | def func(self, name):
method macro_body (line 505) | def macro_body(self, node, frame):
method macro_def (line 582) | def macro_def(self, macro_ref, frame):
method position (line 593) | def position(self, node):
method dump_local_context (line 600) | def dump_local_context(self, frame):
method write_commons (line 605) | def write_commons(self):
method push_parameter_definitions (line 614) | def push_parameter_definitions(self, frame):
method pop_parameter_definitions (line 623) | def pop_parameter_definitions(self):
method mark_parameter_stored (line 627) | def mark_parameter_stored(self, target):
method push_context_reference (line 634) | def push_context_reference(self, target):
method pop_context_reference (line 637) | def pop_context_reference(self):
method get_context_ref (line 640) | def get_context_ref(self):
method get_resolve_func (line 643) | def get_resolve_func(self):
method derive_context (line 649) | def derive_context(self, frame):
method parameter_is_undeclared (line 655) | def parameter_is_undeclared(self, target):
method push_assign_tracking (line 661) | def push_assign_tracking(self):
method pop_assign_tracking (line 665) | def pop_assign_tracking(self, frame):
method visit_Template (line 695) | def visit_Template(self, node, frame=None):
method visit_Block (line 811) | def visit_Block(self, node, frame):
method visit_Extends (line 843) | def visit_Extends(self, node, frame):
method visit_Include (line 890) | def visit_Include(self, node, frame):
method visit_Import (line 944) | def visit_Import(self, node, frame):
method visit_FromImport (line 965) | def visit_FromImport(self, node, frame):
method visit_For (line 1024) | def visit_For(self, node, frame):
method visit_If (line 1154) | def visit_If(self, node, frame):
method visit_Macro (line 1175) | def visit_Macro(self, node, frame):
method visit_CallBlock (line 1186) | def visit_CallBlock(self, node, frame):
method visit_FilterBlock (line 1194) | def visit_FilterBlock(self, node, frame):
method visit_With (line 1205) | def visit_With(self, node, frame):
method visit_ExprStmt (line 1217) | def visit_ExprStmt(self, node, frame):
method visit_Output (line 1221) | def visit_Output(self, node, frame):
method visit_Assign (line 1366) | def visit_Assign(self, node, frame):
method visit_AssignBlock (line 1374) | def visit_AssignBlock(self, node, frame):
method visit_Name (line 1399) | def visit_Name(self, node, frame):
method visit_NSRef (line 1418) | def visit_NSRef(self, node, frame):
method visit_Const (line 1430) | def visit_Const(self, node, frame):
method visit_TemplateData (line 1437) | def visit_TemplateData(self, node, frame):
method visit_Tuple (line 1444) | def visit_Tuple(self, node, frame):
method visit_List (line 1453) | def visit_List(self, node, frame):
method visit_Dict (line 1461) | def visit_Dict(self, node, frame):
method binop (line 1471) | def binop(operator, interceptable=True):
method uaop (line 1488) | def uaop(operator, interceptable=True):
method visit_Concat (line 1516) | def visit_Concat(self, node, frame):
method visit_Compare (line 1531) | def visit_Compare(self, node, frame):
method visit_Operand (line 1536) | def visit_Operand(self, node, frame):
method visit_Getattr (line 1541) | def visit_Getattr(self, node, frame):
method visit_Getitem (line 1547) | def visit_Getitem(self, node, frame):
method visit_Slice (line 1561) | def visit_Slice(self, node, frame):
method visit_Filter (line 1572) | def visit_Filter(self, node, frame):
method visit_Test (line 1604) | def visit_Test(self, node, frame):
method visit_CondExpr (line 1613) | def visit_CondExpr(self, node, frame):
method visit_Call (line 1630) | def visit_Call(self, node, frame, forward_caller=False):
method visit_Keyword (line 1644) | def visit_Keyword(self, node, frame):
method visit_MarkSafe (line 1650) | def visit_MarkSafe(self, node, frame):
method visit_MarkSafeIfAutoescape (line 1655) | def visit_MarkSafeIfAutoescape(self, node, frame):
method visit_EnvironmentAttribute (line 1660) | def visit_EnvironmentAttribute(self, node, frame):
method visit_ExtensionAttribute (line 1663) | def visit_ExtensionAttribute(self, node, frame):
method visit_ImportedName (line 1666) | def visit_ImportedName(self, node, frame):
method visit_InternalName (line 1669) | def visit_InternalName(self, node, frame):
method visit_ContextReference (line 1672) | def visit_ContextReference(self, node, frame):
method visit_Continue (line 1675) | def visit_Continue(self, node, frame):
method visit_Break (line 1678) | def visit_Break(self, node, frame):
method visit_Scope (line 1681) | def visit_Scope(self, node, frame):
method visit_OverlayScope (line 1688) | def visit_OverlayScope(self, node, frame):
method visit_EvalContextModifier (line 1702) | def visit_EvalContextModifier(self, node, frame):
method visit_ScopedEvalContextModifier (line 1713) | def visit_ScopedEvalContextModifier(self, node, frame):
FILE: nuitka/build/inline_copy/jinja2/jinja2/debug.py
class TracebackFrameProxy (line 36) | class TracebackFrameProxy(object):
method __init__ (line 39) | def __init__(self, tb):
method tb_next (line 44) | def tb_next(self):
method set_next (line 47) | def set_next(self, next):
method is_jinja_frame (line 59) | def is_jinja_frame(self):
method __getattr__ (line 62) | def __getattr__(self, name):
function make_frame_proxy (line 66) | def make_frame_proxy(frame):
class ProcessedTraceback (line 80) | class ProcessedTraceback(object):
method __init__ (line 83) | def __init__(self, exc_type, exc_value, frames):
method render_as_text (line 97) | def render_as_text(self, limit=None):
method render_as_html (line 103) | def render_as_html(self, full=False):
method is_template_syntax_error (line 112) | def is_template_syntax_error(self):
method exc_info (line 117) | def exc_info(self):
method standard_exc_info (line 122) | def standard_exc_info(self):
function make_traceback (line 132) | def make_traceback(exc_info, source_hint=None):
function translate_syntax_error (line 143) | def translate_syntax_error(error, source=None):
function translate_exception (line 154) | def translate_exception(exc_info, initial_skip=0):
function get_jinja_locals (line 198) | def get_jinja_locals(real_locals):
function fake_exc_info (line 228) | def fake_exc_info(exc_info, filename, lineno):
function _init_ugly_crap (line 298) | def _init_ugly_crap():
function tb_set_next (line 370) | def tb_set_next(tb, next):
FILE: nuitka/build/inline_copy/jinja2/jinja2/environment.py
function get_spontaneous_environment (line 44) | def get_spontaneous_environment(*args):
function create_cache (line 60) | def create_cache(size):
function copy_cache (line 69) | def copy_cache(cache):
function load_extensions (line 78) | def load_extensions(environment, extensions):
function fail_for_missing_callable (line 90) | def fail_for_missing_callable(string, name):
function _environment_sanity_check (line 100) | def _environment_sanity_check(environment):
class Environment (line 113) | class Environment(object):
method __init__ (line 264) | def __init__(self,
method add_extension (line 340) | def add_extension(self, extension):
method extend (line 347) | def extend(self, **attributes):
method overlay (line 356) | def overlay(self, block_start_string=missing, block_end_string=missing,
method iter_extensions (line 403) | def iter_extensions(self):
method getitem (line 408) | def getitem(self, obj, argument):
method getattr (line 425) | def getattr(self, obj, attribute):
method call_filter (line 438) | def call_filter(self, name, value, args=None, kwargs=None,
method call_test (line 469) | def call_test(self, name, value, args=None, kwargs=None):
method parse (line 480) | def parse(self, source, name=None, filename=None):
method _parse (line 495) | def _parse(self, source, name, filename):
method lex (line 499) | def lex(self, source, name=None, filename=None):
method preprocess (line 516) | def preprocess(self, source, name=None, filename=None):
method _tokenize (line 524) | def _tokenize(self, source, name, filename=None, state=None):
method _generate (line 536) | def _generate(self, source, name, filename, defer_init=False):
method _compile (line 545) | def _compile(self, source, filename):
method compile (line 554) | def compile(self, source, name=None, filename=None, raw=False,
method compile_expression (line 593) | def compile_expression(self, source, undefined_to_none=True):
method compile_templates (line 638) | def compile_templates(self, target, extensions=None, filter_func=None,
method list_templates (line 733) | def list_templates(self, extensions=None, filter_func=None):
method handle_exception (line 760) | def handle_exception(self, exc_info=None, rendered=False, source_hint=...
method join_path (line 782) | def join_path(self, template, parent):
method _load_template (line 795) | def _load_template(self, name, globals):
method get_template (line 810) | def get_template(self, name, parent=None, globals=None):
method select_template (line 833) | def select_template(self, names, parent=None, globals=None):
method get_or_select_template (line 860) | def get_or_select_template(self, template_name_or_list,
method from_string (line 874) | def from_string(self, source, globals=None, template_class=None):
method make_globals (line 882) | def make_globals(self, d):
class Template (line 889) | class Template(object):
method __new__ (line 919) | def __new__(cls, source,
method from_code (line 948) | def from_code(cls, environment, code, globals, uptodate=None):
method from_module_dict (line 962) | def from_module_dict(cls, environment, module_dict, globals):
method _from_namespace (line 971) | def _from_namespace(cls, environment, namespace, globals):
method render (line 993) | def render(self, *args, **kwargs):
method render_async (line 1010) | def render_async(self, *args, **kwargs):
method stream (line 1023) | def stream(self, *args, **kwargs):
method generate (line 1029) | def generate(self, *args, **kwargs):
method generate_async (line 1047) | def generate_async(self, *args, **kwargs):
method new_context (line 1055) | def new_context(self, vars=None, shared=False, locals=None):
method make_module (line 1066) | def make_module(self, vars=None, shared=False, locals=None):
method make_module_async (line 1075) | def make_module_async(self, vars=None, shared=False, locals=None):
method _get_default_module (line 1086) | def _get_default_module(self):
method module (line 1093) | def module(self):
method get_corresponding_lineno (line 1108) | def get_corresponding_lineno(self, lineno):
method is_up_to_date (line 1118) | def is_up_to_date(self):
method debug_info (line 1125) | def debug_info(self):
method __repr__ (line 1130) | def __repr__(self):
class TemplateModule (line 1139) | class TemplateModule(object):
method __init__ (line 1145) | def __init__(self, template, context, body_stream=None):
method __html__ (line 1157) | def __html__(self):
method __str__ (line 1160) | def __str__(self):
method __repr__ (line 1163) | def __repr__(self):
class TemplateExpression (line 1171) | class TemplateExpression(object):
method __init__ (line 1177) | def __init__(self, template, undefined_to_none):
method __call__ (line 1181) | def __call__(self, *args, **kwargs):
class TemplateStream (line 1191) | class TemplateStream(object):
method __init__ (line 1202) | def __init__(self, gen):
method dump (line 1206) | def dump(self, fp, encoding=None, errors='strict'):
method disable_buffering (line 1235) | def disable_buffering(self):
method _buffered_generator (line 1240) | def _buffered_generator(self, size):
method enable_buffering (line 1259) | def enable_buffering(self, size=5):
method __iter__ (line 1267) | def __iter__(self):
method __next__ (line 1270) | def __next__(self):
FILE: nuitka/build/inline_copy/jinja2/jinja2/exceptions.py
class TemplateError (line 14) | class TemplateError(Exception):
method __init__ (line 18) | def __init__(self, message=None):
method message (line 24) | def message(self):
method __unicode__ (line 30) | def __unicode__(self):
method __init__ (line 33) | def __init__(self, message=None):
method message (line 37) | def message(self):
class TemplateNotFound (line 45) | class TemplateNotFound(IOError, LookupError, TemplateError):
method __init__ (line 52) | def __init__(self, name, message=None):
method __str__ (line 60) | def __str__(self):
class TemplatesNotFound (line 64) | class TemplatesNotFound(TemplateNotFound):
method __init__ (line 72) | def __init__(self, names=(), message=None):
class TemplateSyntaxError (line 81) | class TemplateSyntaxError(TemplateError):
method __init__ (line 84) | def __init__(self, message, lineno, name=None, filename=None):
method __str__ (line 95) | def __str__(self):
class TemplateAssertionError (line 119) | class TemplateAssertionError(TemplateSyntaxError):
class TemplateRuntimeError (line 127) | class TemplateRuntimeError(TemplateError):
class UndefinedError (line 133) | class UndefinedError(TemplateRuntimeError):
class SecurityError (line 137) | class SecurityError(TemplateRuntimeError):
class FilterArgumentError (line 143) | class FilterArgumentError(TemplateRuntimeError):
FILE: nuitka/build/inline_copy/jinja2/jinja2/ext.py
class ExtensionRegistry (line 34) | class ExtensionRegistry(type):
method __new__ (line 37) | def __new__(cls, name, bases, d):
class Extension (line 43) | class Extension(with_metaclass(ExtensionRegistry, object)):
method __init__ (line 72) | def __init__(self, environment):
method bind (line 75) | def bind(self, environment):
method preprocess (line 82) | def preprocess(self, source, name, filename=None):
method filter_stream (line 89) | def filter_stream(self, stream):
method parse (line 101) | def parse(self, parser):
method attr (line 109) | def attr(self, name, lineno=None):
method call_method (line 119) | def call_method(self, name, args=None, kwargs=None, dyn_args=None,
function _gettext_alias (line 133) | def _gettext_alias(__context, *args, **kwargs):
function _make_new_gettext (line 137) | def _make_new_gettext(func):
function _make_new_ngettext (line 147) | def _make_new_ngettext(func):
class InternationalizationExtension (line 158) | class InternationalizationExtension(Extension):
method __init__ (line 169) | def __init__(self, environment):
method _install (line 181) | def _install(self, translations, newstyle=None):
method _install_null (line 190) | def _install_null(self, newstyle=None):
method _install_callables (line 197) | def _install_callables(self, gettext, ngettext, newstyle=None):
method _uninstall (line 208) | def _uninstall(self, translations):
method _extract (line 212) | def _extract(self, source, gettext_functions=GETTEXT_FUNCTIONS):
method parse (line 217) | def parse(self, parser):
method _trim_whitespace (line 322) | def _trim_whitespace(self, string, _ws_re=re.compile(r'\s*\n\s*')):
method _parse_block (line 325) | def _parse_block(self, parser, allow_pluralize):
method _make_node (line 357) | def _make_node(self, singular, plural, variables, plural_expr,
class ExprStmtExtension (line 406) | class ExprStmtExtension(Extension):
method parse (line 412) | def parse(self, parser):
class LoopControlExtension (line 418) | class LoopControlExtension(Extension):
method parse (line 422) | def parse(self, parser):
class WithExtension (line 429) | class WithExtension(Extension):
class AutoEscapeExtension (line 433) | class AutoEscapeExtension(Extension):
function extract_from_ast (line 437) | def extract_from_ast(node, gettext_functions=GETTEXT_FUNCTIONS,
class _CommentFinder (line 505) | class _CommentFinder(object):
method __init__ (line 512) | def __init__(self, tokens, comment_tags):
method find_backwards (line 518) | def find_backwards(self, offset):
method find_comments (line 533) | def find_comments(self, lineno):
function babel_extract (line 542) | def babel_extract(fileobj, keywords, comment_tags, options):
FILE: nuitka/build/inline_copy/jinja2/jinja2/filters.py
function contextfilter (line 29) | def contextfilter(f):
function evalcontextfilter (line 37) | def evalcontextfilter(f):
function environmentfilter (line 48) | def environmentfilter(f):
function ignore_case (line 56) | def ignore_case(value):
function make_attrgetter (line 62) | def make_attrgetter(environment, attribute, postprocess=None):
function do_forceescape (line 87) | def do_forceescape(value):
function do_urlencode (line 94) | def do_urlencode(value):
function do_replace (line 116) | def do_replace(eval_ctx, s, old, new, count=None):
function do_upper (line 143) | def do_upper(s):
function do_lower (line 148) | def do_lower(s):
function do_xmlattr (line 154) | def do_xmlattr(_eval_ctx, d, autospace=True):
function do_capitalize (line 189) | def do_capitalize(s):
function do_title (line 196) | def do_title(s):
function do_dictsort (line 206) | def do_dictsort(value, case_sensitive=False, by='key', reverse=False):
function do_sort (line 246) | def do_sort(
function do_unique (line 282) | def do_unique(environment, value, case_sensitive=False, attribute=None):
function _min_or_max (line 310) | def _min_or_max(environment, value, func, case_sensitive, attribute):
function do_min (line 326) | def do_min(environment, value, case_sensitive=False, attribute=None):
function do_max (line 341) | def do_max(environment, value, case_sensitive=False, attribute=None):
function do_default (line 355) | def do_default(value, default_value=u'', boolean=False):
function do_join (line 378) | def do_join(eval_ctx, value, d=u'', attribute=None):
function do_center (line 427) | def do_center(value, width=80):
function do_first (line 433) | def do_first(environment, seq):
function do_last (line 442) | def do_last(environment, seq):
function do_random (line 451) | def do_random(context, seq):
function do_filesizeformat (line 459) | def do_filesizeformat(value, binary=False):
function do_pprint (line 489) | def do_pprint(value, verbose=False):
function do_urlize (line 499) | def do_urlize(eval_ctx, value, trim_url_limit=None, nofollow=False,
function do_indent (line 536) | def do_indent(
function do_truncate (line 578) | def do_truncate(env, s, length=255, killwords=False, end='...', leeway=N...
function do_wordwrap (line 615) | def do_wordwrap(environment, s, width=79, break_long_words=True,
function do_wordcount (line 636) | def do_wordcount(s):
function do_int (line 641) | def do_int(value, default=0, base=10):
function do_float (line 662) | def do_float(value, default=0.0):
function do_format (line 673) | def do_format(value, *args, **kwargs):
function do_trim (line 688) | def do_trim(value):
function do_striptags (line 693) | def do_striptags(value):
function do_slice (line 701) | def do_slice(value, slices, fill_with=None):
function do_batch (line 737) | def do_batch(value, linecount, fill_with=None):
function do_round (line 768) | def do_round(value, precision=0, method='common'):
function do_groupby (line 812) | def do_groupby(environment, value, attribute):
function do_sum (line 856) | def do_sum(environment, iterable, attribute=None, start=0):
function do_list (line 876) | def do_list(value):
function do_mark_safe (line 883) | def do_mark_safe(value):
function do_mark_unsafe (line 890) | def do_mark_unsafe(value):
function do_reverse (line 895) | def do_reverse(value):
function do_attr (line 913) | def do_attr(environment, obj, name):
function do_map (line 938) | def do_map(*args, **kwargs):
function do_select (line 967) | def do_select(*args, **kwargs):
function do_reject (line 989) | def do_reject(*args, **kwargs):
function do_selectattr (line 1007) | def do_selectattr(*args, **kwargs):
function do_rejectattr (line 1028) | def do_rejectattr(*args, **kwargs):
function do_tojson (line 1047) | def do_tojson(eval_ctx, value, indent=None):
function prepare_map (line 1081) | def prepare_map(args, kwargs):
function prepare_select_or_reject (line 1103) | def prepare_select_or_reject(args, kwargs, modfunc, lookup_attr):
function select_or_reject (line 1128) | def select_or_reject(args, kwargs, modfunc, lookup_attr):
FILE: nuitka/build/inline_copy/jinja2/jinja2/idtracking.py
function find_symbols (line 11) | def find_symbols(nodes, parent_symbols=None):
function symbols_for_node (line 19) | def symbols_for_node(node, parent_symbols=None):
class Symbols (line 25) | class Symbols(object):
method __init__ (line 27) | def __init__(self, parent=None, level=None):
method analyze_node (line 39) | def analyze_node(self, node, **kwargs):
method _define_ref (line 43) | def _define_ref(self, name, load=None):
method find_load (line 50) | def find_load(self, target):
method find_ref (line 56) | def find_ref(self, name):
method ref (line 62) | def ref(self, name):
method copy (line 69) | def copy(self):
method store (line 77) | def store(self, name):
method declare_parameter (line 95) | def declare_parameter(self, name):
method load (line 99) | def load(self, name):
method branch_update (line 104) | def branch_update(self, branch_symbols):
method dump_stores (line 130) | def dump_stores(self):
method dump_param_targets (line 140) | def dump_param_targets(self):
class RootVisitor (line 151) | class RootVisitor(NodeVisitor):
method __init__ (line 153) | def __init__(self, symbols):
method _simple_visit (line 156) | def _simple_visit(self, node, **kwargs):
method visit_AssignBlock (line 164) | def visit_AssignBlock(self, node, **kwargs):
method visit_CallBlock (line 168) | def visit_CallBlock(self, node, **kwargs):
method visit_OverlayScope (line 172) | def visit_OverlayScope(self, node, **kwargs):
method visit_For (line 176) | def visit_For(self, node, for_branch='body', **kwargs):
method visit_With (line 192) | def visit_With(self, node, **kwargs):
method generic_visit (line 198) | def generic_visit(self, node, *args, **kwargs):
class FrameSymbolVisitor (line 203) | class FrameSymbolVisitor(NodeVisitor):
method __init__ (line 206) | def __init__(self, symbols):
method visit_Name (line 209) | def visit_Name(self, node, store_as_param=False, **kwargs):
method visit_NSRef (line 218) | def visit_NSRef(self, node, **kwargs):
method visit_If (line 221) | def visit_If(self, node, **kwargs):
method visit_Macro (line 239) | def visit_Macro(self, node, **kwargs):
method visit_Import (line 242) | def visit_Import(self, node, **kwargs):
method visit_FromImport (line 246) | def visit_FromImport(self, node, **kwargs):
method visit_Assign (line 254) | def visit_Assign(self, node, **kwargs):
method visit_For (line 259) | def visit_For(self, node, **kwargs):
method visit_CallBlock (line 265) | def visit_CallBlock(self, node, **kwargs):
method visit_FilterBlock (line 268) | def visit_FilterBlock(self, node, **kwargs):
method visit_With (line 271) | def visit_With(self, node, **kwargs):
method visit_AssignBlock (line 275) | def visit_AssignBlock(self, node, **kwargs):
method visit_Scope (line 279) | def visit_Scope(self, node, **kwargs):
method visit_Block (line 282) | def visit_Block(self, node, **kwargs):
method visit_OverlayScope (line 285) | def visit_OverlayScope(self, node, **kwargs):
FILE: nuitka/build/inline_copy/jinja2/jinja2/lexer.py
function _describe_token_type (line 152) | def _describe_token_type(token_type):
function describe_token (line 171) | def describe_token(token):
function describe_token_expr (line 178) | def describe_token_expr(expr):
function count_newlines (line 189) | def count_newlines(value):
function compile_rules (line 196) | def compile_rules(environment):
class Failure (line 219) | class Failure(object):
method __init__ (line 224) | def __init__(self, message, cls=TemplateSyntaxError):
method __call__ (line 228) | def __call__(self, lineno, filename):
class Token (line 232) | class Token(tuple):
method __new__ (line 237) | def __new__(cls, lineno, type, value):
method __str__ (line 240) | def __str__(self):
method test (line 247) | def test(self, expr):
method test_any (line 260) | def test_any(self, *iterable):
method __repr__ (line 267) | def __repr__(self):
class TokenStreamIterator (line 276) | class TokenStreamIterator(object):
method __init__ (line 281) | def __init__(self, stream):
method __iter__ (line 284) | def __iter__(self):
method __next__ (line 287) | def __next__(self):
class TokenStream (line 297) | class TokenStream(object):
method __init__ (line 303) | def __init__(self, generator, name, filename):
method __iter__ (line 312) | def __iter__(self):
method __bool__ (line 315) | def __bool__(self):
method push (line 321) | def push(self, token):
method look (line 325) | def look(self):
method skip (line 333) | def skip(self, n=1):
method next_if (line 338) | def next_if(self, expr):
method skip_if (line 345) | def skip_if(self, expr):
method __next__ (line 349) | def __next__(self):
method close (line 364) | def close(self):
method expect (line 370) | def expect(self, expr):
function get_lexer (line 391) | def get_lexer(environment):
class Lexer (line 412) | class Lexer(object):
method __init__ (line 420) | def __init__(self, environment):
method _normalize_newlines (line 548) | def _normalize_newlines(self, value):
method tokenize (line 552) | def tokenize(self, source, name=None, filename=None, state=None):
method wrap (line 558) | def wrap(self, stream, name=None, filename=None):
method tokeniter (line 599) | def tokeniter(self, source, name, filename=None, state=None):
FILE: nuitka/build/inline_copy/jinja2/jinja2/loaders.py
function split_template_path (line 22) | def split_template_path(template):
class BaseLoader (line 37) | class BaseLoader(object):
method get_source (line 70) | def get_source(self, environment, template):
method list_templates (line 93) | def list_templates(self):
method load (line 100) | def load(self, environment, name, globals=None):
class FileSystemLoader (line 138) | class FileSystemLoader(BaseLoader):
method __init__ (line 160) | def __init__(self, searchpath, encoding='utf-8', followlinks=False):
method get_source (line 167) | def get_source(self, environment, template):
method list_templates (line 189) | def list_templates(self):
class PackageLoader (line 209) | class PackageLoader(BaseLoader):
method __init__ (line 224) | def __init__(self, package_name, package_path='templates',
method get_source (line 233) | def get_source(self, environment, template):
method list_templates (line 252) | def list_templates(self):
class DictLoader (line 272) | class DictLoader(BaseLoader):
method __init__ (line 281) | def __init__(self, mapping):
method get_source (line 284) | def get_source(self, environment, template):
method list_templates (line 290) | def list_templates(self):
class FunctionLoader (line 294) | class FunctionLoader(BaseLoader):
method __init__ (line 312) | def __init__(self, load_func):
method get_source (line 315) | def get_source(self, environment, template):
class PrefixLoader (line 324) | class PrefixLoader(BaseLoader):
method __init__ (line 339) | def __init__(self, mapping, delimiter='/'):
method get_loader (line 343) | def get_loader(self, template):
method get_source (line 351) | def get_source(self, environment, template):
method load (line 361) | def load(self, environment, name, globals=None):
method list_templates (line 370) | def list_templates(self):
class ChoiceLoader (line 378) | class ChoiceLoader(BaseLoader):
method __init__ (line 392) | def __init__(self, loaders):
method get_source (line 395) | def get_source(self, environment, template):
method load (line 404) | def load(self, environment, name, globals=None):
method list_templates (line 412) | def list_templates(self):
class _TemplateModule (line 419) | class _TemplateModule(ModuleType):
class ModuleLoader (line 423) | class ModuleLoader(BaseLoader):
method __init__ (line 438) | def __init__(self, path):
method get_template_key (line 460) | def get_template_key(name):
method get_module_filename (line 464) | def get_module_filename(name):
method load (line 468) | def load(self, environment, name, globals=None):
FILE: nuitka/build/inline_copy/jinja2/jinja2/meta.py
class TrackingCodeGenerator (line 17) | class TrackingCodeGenerator(CodeGenerator):
method __init__ (line 20) | def __init__(self, environment):
method write (line 25) | def write(self, x):
method enter_frame (line 28) | def enter_frame(self, frame):
function find_undeclared_variables (line 36) | def find_undeclared_variables(ast):
function find_referenced_templates (line 60) | def find_referenced_templates(ast):
FILE: nuitka/build/inline_copy/jinja2/jinja2/nativetypes.py
function native_concat (line 11) | def native_concat(nodes):
class NativeCodeGenerator (line 34) | class NativeCodeGenerator(CodeGenerator):
method visit_Output (line 39) | def visit_Output(self, node, frame):
class NativeTemplate (line 198) | class NativeTemplate(Template):
method render (line 199) | def render(self, *args, **kwargs):
class NativeEnvironment (line 216) | class NativeEnvironment(Environment):
FILE: nuitka/build/inline_copy/jinja2/jinja2/nodes.py
class Impossible (line 55) | class Impossible(Exception):
class NodeType (line 59) | class NodeType(type):
method __new__ (line 64) | def __new__(cls, name, bases, d):
class EvalContext (line 76) | class EvalContext(object):
method __init__ (line 81) | def __init__(self, environment, template_name=None):
method save (line 89) | def save(self):
method revert (line 92) | def revert(self, old):
function get_eval_context (line 97) | def get_eval_context(node, ctx):
class Node (line 107) | class Node(with_metaclass(NodeType, object)):
method __init__ (line 127) | def __init__(self, *fields, **attributes):
method iter_fields (line 148) | def iter_fields(self, exclude=None, only=None):
method iter_child_nodes (line 164) | def iter_child_nodes(self, exclude=None, only=None):
method find (line 177) | def find(self, node_type):
method find_all (line 184) | def find_all(self, node_type):
method set_ctx (line 194) | def set_ctx(self, ctx):
method set_lineno (line 208) | def set_lineno(self, lineno, override=False):
method set_environment (line 219) | def set_environment(self, environment):
method __eq__ (line 228) | def __eq__(self, other):
method __ne__ (line 232) | def __ne__(self, other):
method __repr__ (line 238) | def __repr__(self):
method dump (line 245) | def dump(self):
class Stmt (line 275) | class Stmt(Node):
class Helper (line 280) | class Helper(Node):
class Template (line 285) | class Template(Node):
class Output (line 292) | class Output(Stmt):
class Extends (line 299) | class Extends(Stmt):
class For (line 304) | class For(Stmt):
class If (line 315) | class If(Stmt):
class Macro (line 320) | class Macro(Stmt):
class CallBlock (line 328) | class CallBlock(Stmt):
class FilterBlock (line 335) | class FilterBlock(Stmt):
class With (line 340) | class With(Stmt):
class Block (line 349) | class Block(Stmt):
class Include (line 354) | class Include(Stmt):
class Import (line 359) | class Import(Stmt):
class FromImport (line 364) | class FromImport(Stmt):
class ExprStmt (line 378) | class ExprStmt(Stmt):
class Assign (line 383) | class Assign(Stmt):
class AssignBlock (line 388) | class AssignBlock(Stmt):
class Expr (line 393) | class Expr(Node):
method as_const (line 397) | def as_const(self, eval_ctx=None):
method can_assign (line 410) | def can_assign(self):
class BinExpr (line 415) | class BinExpr(Expr):
method as_const (line 421) | def as_const(self, eval_ctx=None):
class UnaryExpr (line 434) | class UnaryExpr(Expr):
method as_const (line 440) | def as_const(self, eval_ctx=None):
class Name (line 453) | class Name(Expr):
method can_assign (line 463) | def can_assign(self):
class NSRef (line 468) | class NSRef(Expr):
method can_assign (line 472) | def can_assign(self):
class Literal (line 480) | class Literal(Expr):
class Const (line 485) | class Const(Literal):
method as_const (line 493) | def as_const(self, eval_ctx=None):
method from_untrusted (line 504) | def from_untrusted(cls, value, lineno=None, environment=None):
class TemplateData (line 515) | class TemplateData(Literal):
method as_const (line 519) | def as_const(self, eval_ctx=None):
class Tuple (line 528) | class Tuple(Literal):
method as_const (line 535) | def as_const(self, eval_ctx=None):
method can_assign (line 539) | def can_assign(self):
class List (line 546) | class List(Literal):
method as_const (line 550) | def as_const(self, eval_ctx=None):
class Dict (line 555) | class Dict(Literal):
method as_const (line 561) | def as_const(self, eval_ctx=None):
class Pair (line 566) | class Pair(Helper):
method as_const (line 570) | def as_const(self, eval_ctx=None):
class Keyword (line 575) | class Keyword(Helper):
method as_const (line 579) | def as_const(self, eval_ctx=None):
class CondExpr (line 584) | class CondExpr(Expr):
method as_const (line 590) | def as_const(self, eval_ctx=None):
function args_as_const (line 602) | def args_as_const(node, eval_ctx):
class Filter (line 621) | class Filter(Expr):
method as_const (line 631) | def as_const(self, eval_ctx=None):
class Test (line 669) | class Test(Expr):
method as_const (line 676) | def as_const(self, eval_ctx=None):
class Call (line 692) | class Call(Expr):
class Getitem (line 702) | class Getitem(Expr):
method as_const (line 706) | def as_const(self, eval_ctx=None):
method can_assign (line 716) | def can_assign(self):
class Getattr (line 720) | class Getattr(Expr):
method as_const (line 726) | def as_const(self, eval_ctx=None):
method can_assign (line 736) | def can_assign(self):
class Slice (line 740) | class Slice(Expr):
method as_const (line 746) | def as_const(self, eval_ctx=None):
class Concat (line 755) | class Concat(Expr):
method as_const (line 761) | def as_const(self, eval_ctx=None):
class Compare (line 766) | class Compare(Expr):
method as_const (line 772) | def as_const(self, eval_ctx=None):
class Operand (line 785) | class Operand(Helper):
class Mul (line 795) | class Mul(BinExpr):
class Div (line 800) | class Div(BinExpr):
class FloorDiv (line 805) | class FloorDiv(BinExpr):
class Add (line 812) | class Add(BinExpr):
class Sub (line 817) | class Sub(BinExpr):
class Mod (line 822) | class Mod(BinExpr):
class Pow (line 827) | class Pow(BinExpr):
class And (line 832) | class And(BinExpr):
method as_const (line 836) | def as_const(self, eval_ctx=None):
class Or (line 841) | class Or(BinExpr):
method as_const (line 845) | def as_const(self, eval_ctx=None):
class Not (line 850) | class Not(UnaryExpr):
class Neg (line 855) | class Neg(UnaryExpr):
class Pos (line 860) | class Pos(UnaryExpr):
class EnvironmentAttribute (line 868) | class EnvironmentAttribute(Expr):
class ExtensionAttribute (line 875) | class ExtensionAttribute(Expr):
class ImportedName (line 885) | class ImportedName(Expr):
class InternalName (line 894) | class InternalName(Expr):
method __init__ (line 903) | def __init__(self):
class MarkSafe (line 908) | class MarkSafe(Expr):
method as_const (line 912) | def as_const(self, eval_ctx=None):
class MarkSafeIfAutoescape (line 917) | class MarkSafeIfAutoescape(Expr):
method as_const (line 925) | def as_const(self, eval_ctx=None):
class ContextReference (line 935) | class ContextReference(Expr):
class Continue (line 948) | class Continue(Stmt):
class Break (line 952) | class Break(Stmt):
class Scope (line 956) | class Scope(Stmt):
class OverlayScope (line 961) | class OverlayScope(Stmt):
class EvalContextModifier (line 977) | class EvalContextModifier(Stmt):
class ScopedEvalContextModifier (line 988) | class ScopedEvalContextModifier(EvalContextModifier):
function _failing_new (line 997) | def _failing_new(*args, **kwargs):
FILE: nuitka/build/inline_copy/jinja2/jinja2/optimizer.py
function optimize (line 23) | def optimize(node, environment):
class Optimizer (line 30) | class Optimizer(NodeTransformer):
method __init__ (line 32) | def __init__(self, environment):
method fold (line 35) | def fold(self, node, eval_ctx=None):
FILE: nuitka/build/inline_copy/jinja2/jinja2/parser.py
class Parser (line 32) | class Parser(object):
method __init__ (line 37) | def __init__(self, environment, source, name=None, filename=None,
method fail (line 52) | def fail(self, msg, lineno=None, exc=TemplateSyntaxError):
method _fail_ut_eof (line 61) | def _fail_ut_eof(self, name, end_token_stack, lineno):
method fail_unknown_tag (line 92) | def fail_unknown_tag(self, name, lineno=None):
method fail_eof (line 99) | def fail_eof(self, end_tokens=None, lineno=None):
method is_tuple_end (line 106) | def is_tuple_end(self, extra_end_rules=None):
method free_identifier (line 114) | def free_identifier(self, lineno=None):
method parse_statement (line 121) | def parse_statement(self):
method parse_statements (line 149) | def parse_statements(self, end_tokens, drop_needle=False):
method parse_set (line 176) | def parse_set(self):
method parse_for (line 188) | def parse_for(self):
method parse_if (line 207) | def parse_if(self):
method parse_with (line 227) | def parse_with(self):
method parse_autoescape (line 246) | def parse_autoescape(self):
method parse_block (line 255) | def parse_block(self):
method parse_extends (line 272) | def parse_extends(self):
method parse_import_context (line 277) | def parse_import_context(self, node, default):
method parse_include (line 286) | def parse_include(self):
method parse_import (line 297) | def parse_import(self):
method parse_from (line 304) | def parse_from(self):
method parse_signature (line 342) | def parse_signature(self, node):
method parse_call_block (line 358) | def parse_call_block(self):
method parse_filter_block (line 372) | def parse_filter_block(self):
method parse_macro (line 379) | def parse_macro(self):
method parse_print (line 387) | def parse_print(self):
method parse_assign_target (line 396) | def parse_assign_target(self, with_tuple=True, name_only=False,
method parse_expression (line 426) | def parse_expression(self, with_condexpr=True):
method parse_condexpr (line 435) | def parse_condexpr(self):
method parse_or (line 448) | def parse_or(self):
method parse_and (line 457) | def parse_and(self):
method parse_not (line 466) | def parse_not(self):
method parse_compare (line 472) | def parse_compare(self):
method parse_math1 (line 494) | def parse_math1(self):
method parse_concat (line 505) | def parse_concat(self):
method parse_math2 (line 515) | def parse_math2(self):
method parse_pow (line 526) | def parse_pow(self):
method parse_unary (line 536) | def parse_unary(self, with_filter=True):
method parse_primary (line 552) | def parse_primary(self):
method parse_tuple (line 586) | def parse_tuple(self, simplified=False, with_condexpr=True,
method parse_list (line 641) | def parse_list(self):
method parse_dict (line 653) | def parse_dict(self):
method parse_postfix (line 668) | def parse_postfix(self, node):
method parse_filter_expr (line 681) | def parse_filter_expr(self, node):
method parse_subscript (line 696) | def parse_subscript(self, node):
method parse_subscribed (line 722) | def parse_subscribed(self):
method parse_call (line 753) | def parse_call(self, node):
method parse_filter (line 800) | def parse_filter(self, node, start_inline=False):
method parse_test (line 820) | def parse_test(self, node):
method subparse (line 851) | def subparse(self, end_tokens=None):
method parse (line 899) | def parse(self):
FILE: nuitka/build/inline_copy/jinja2/jinja2/runtime.py
function markup_join (line 43) | def markup_join(seq):
function unicode_join (line 54) | def unicode_join(seq):
function new_context (line 59) | def new_context(environment, template_name, blocks, vars=None,
class TemplateReference (line 80) | class TemplateReference(object):
method __init__ (line 83) | def __init__(self, context):
method __getitem__ (line 86) | def __getitem__(self, name):
method __repr__ (line 90) | def __repr__(self):
function _get_func (line 97) | def _get_func(x):
class ContextMeta (line 101) | class ContextMeta(type):
method __new__ (line 103) | def __new__(cls, name, bases, d):
function resolve_or_missing (line 125) | def resolve_or_missing(context, key, missing=missing):
class Context (line 133) | class Context(with_metaclass(ContextMeta)):
method __init__ (line 157) | def __init__(self, environment, parent, name, blocks):
method super (line 175) | def super(self, name, current):
method get (line 187) | def get(self, key, default=None):
method resolve (line 196) | def resolve(self, key):
method resolve_or_missing (line 208) | def resolve_or_missing(self, key):
method get_exported (line 219) | def get_exported(self):
method get_all (line 223) | def get_all(self):
method call (line 235) | def call(__self, __obj, *args, **kwargs):
method derived (line 268) | def derived(self, locals=None):
method _all (line 279) | def _all(meth):
method __contains__ (line 296) | def __contains__(self, name):
method __getitem__ (line 299) | def __getitem__(self, key):
method __repr__ (line 308) | def __repr__(self):
class BlockReference (line 319) | class BlockReference(object):
method __init__ (line 322) | def __init__(self, name, context, stack, depth):
method super (line 329) | def super(self):
method __call__ (line 339) | def __call__(self):
class LoopContextBase (line 346) | class LoopContextBase(object):
method __init__ (line 354) | def __init__(self, undefined, recurse=None, depth0=0):
method cycle (line 361) | def cycle(self, *args):
method changed (line 367) | def changed(self, *value):
method previtem (line 382) | def previtem(self):
method nextitem (line 388) | def nextitem(self):
method __len__ (line 393) | def __len__(self):
method loop (line 397) | def loop(self, iterable):
method __repr__ (line 408) | def __repr__(self):
class LoopContext (line 416) | class LoopContext(LoopContextBase):
method __init__ (line 418) | def __init__(self, iterable, undefined, recurse=None, depth0=0):
method length (line 433) | def length(self):
method __iter__ (line 445) | def __iter__(self):
method _safe_next (line 448) | def _safe_next(self):
class LoopContextIterator (line 456) | class LoopContextIterator(object):
method __init__ (line 460) | def __init__(self, context):
method __iter__ (line 463) | def __iter__(self):
method __next__ (line 466) | def __next__(self):
class Macro (line 477) | class Macro(object):
method __init__ (line 480) | def __init__(self, environment, func, name, arguments,
method __call__ (line 498) | def __call__(self, *args, **kwargs):
method _invoke (line 572) | def _invoke(self, arguments, autoescape):
method __repr__ (line 579) | def __repr__(self):
class Undefined (line 587) | class Undefined(object):
method __init__ (line 604) | def __init__(self, hint=None, obj=missing, name=None, exc=UndefinedErr...
method _fail_with_undefined_error (line 611) | def _fail_with_undefined_error(self, *args, **kwargs):
method __getattr__ (line 633) | def __getattr__(self, name):
method __eq__ (line 645) | def __eq__(self, other):
method __ne__ (line 648) | def __ne__(self, other):
method __hash__ (line 651) | def __hash__(self):
method __str__ (line 654) | def __str__(self):
method __len__ (line 657) | def __len__(self):
method __iter__ (line 660) | def __iter__(self):
method __nonzero__ (line 664) | def __nonzero__(self):
method __repr__ (line 668) | def __repr__(self):
function make_logging_undefined (line 672) | def make_logging_undefined(logger=None, base=None):
class DebugUndefined (line 754) | class DebugUndefined(Undefined):
method __str__ (line 769) | def __str__(self):
class StrictUndefined (line 781) | class StrictUndefined(Undefined):
FILE: nuitka/build/inline_copy/jinja2/jinja2/sandbox.py
class _MagicFormatMapping (line 104) | class _MagicFormatMapping(abc.Mapping):
method __init__ (line 112) | def __init__(self, args, kwargs):
method __getitem__ (line 117) | def __getitem__(self, key):
method __iter__ (line 128) | def __iter__(self):
method __len__ (line 131) | def __len__(self):
function inspect_format_method (line 135) | def inspect_format_method(callable):
function safe_range (line 145) | def safe_range(*args):
function unsafe (line 160) | def unsafe(f):
function is_internal_attribute (line 173) | def is_internal_attribute(obj, attr):
function modifies_known_mutable (line 209) | def modifies_known_mutable(obj, attr):
class SandboxedEnvironment (line 237) | class SandboxedEnvironment(Environment):
method intercept_unop (line 301) | def intercept_unop(self, operator):
method __init__ (line 319) | def __init__(self, *args, **kwargs):
method is_safe_attribute (line 325) | def is_safe_attribute(self, obj, attr, value):
method is_safe_callable (line 334) | def is_safe_callable(self, obj):
method call_binop (line 343) | def call_binop(self, context, operator, left, right):
method call_unop (line 352) | def call_unop(self, context, operator, arg):
method getitem (line 361) | def getitem(self, obj, argument):
method getattr (line 382) | def getattr(self, obj, attribute):
method unsafe_undefined (line 399) | def unsafe_undefined(self, obj, attribute):
method format_string (line 407) | def format_string(self, s, args, kwargs, format_func=None):
method call (line 430) | def call(__self, __context, __obj, *args, **kwargs):
class ImmutableSandboxedEnvironment (line 443) | class ImmutableSandboxedEnvironment(SandboxedEnvironment):
method is_safe_attribute (line 449) | def is_safe_attribute(self, obj, attr, value):
function formatter_field_name_split (line 459) | def formatter_field_name_split(field_name):
class SandboxedFormatterMixin (line 463) | class SandboxedFormatterMixin(object):
method __init__ (line 465) | def __init__(self, env):
method get_field (line 468) | def get_field(self, field_name, args, kwargs):
class SandboxedFormatter (line 478) | class SandboxedFormatter(SandboxedFormatterMixin, Formatter):
method __init__ (line 480) | def __init__(self, env):
class SandboxedEscapeFormatter (line 484) | class SandboxedEscapeFormatter(SandboxedFormatterMixin, EscapeFormatter):
method __init__ (line 486) | def __init__(self, env, escape):
FILE: nuitka/build/inline_copy/jinja2/jinja2/tests.py
function test_odd (line 24) | def test_odd(value):
function test_even (line 29) | def test_even(value):
function test_divisibleby (line 34) | def test_divisibleby(value, num):
function test_defined (line 39) | def test_defined(value):
function test_undefined (line 56) | def test_undefined(value):
function test_none (line 61) | def test_none(value):
function test_lower (line 66) | def test_lower(value):
function test_upper (line 71) | def test_upper(value):
function test_string (line 76) | def test_string(value):
function test_mapping (line 81) | def test_mapping(value):
function test_number (line 89) | def test_number(value):
function test_sequence (line 94) | def test_sequence(value):
function test_sameas (line 106) | def test_sameas(value, other):
function test_iterable (line 119) | def test_iterable(value):
function test_escaped (line 128) | def test_escaped(value):
function test_in (line 133) | def test_in(value, seq):
FILE: nuitka/build/inline_copy/jinja2/jinja2/utils.py
function contextfunction (line 44) | def contextfunction(f):
function evalcontextfunction (line 60) | def evalcontextfunction(f):
function environmentfunction (line 73) | def environmentfunction(f):
function internalcode (line 83) | def internalcode(f):
function is_undefined (line 89) | def is_undefined(obj):
function consume (line 105) | def consume(iterable):
function clear_caches (line 111) | def clear_caches():
function import_string (line 123) | def import_string(import_name, silent=False):
function open_if_exists (line 149) | def open_if_exists(filename, mode='rb'):
function object_type_repr (line 160) | def object_type_repr(obj):
function pformat (line 177) | def pformat(obj, verbose=False):
function urlize (line 189) | def urlize(text, trim_url_limit=None, rel=None, target=None):
function generate_lorem_ipsum (line 238) | def generate_lorem_ipsum(n=5, html=True, min=20, max=100):
function unicode_urlencode (line 287) | def unicode_urlencode(obj, charset='utf-8', for_qs=False):
class LRUCache (line 306) | class LRUCache(object):
method __init__ (line 313) | def __init__(self, capacity):
method _postinit (line 319) | def _postinit(self):
method __getstate__ (line 327) | def __getstate__(self):
method __setstate__ (line 334) | def __setstate__(self, d):
method __getnewargs__ (line 338) | def __getnewargs__(self):
method copy (line 341) | def copy(self):
method get (line 348) | def get(self, key, default=None):
method setdefault (line 355) | def setdefault(self, key, default=None):
method clear (line 369) | def clear(self):
method __contains__ (line 378) | def __contains__(self, key):
method __len__ (line 382) | def __len__(self):
method __repr__ (line 386) | def __repr__(self):
method __getitem__ (line 392) | def __getitem__(self, key):
method __setitem__ (line 414) | def __setitem__(self, key, value):
method __delitem__ (line 429) | def __delitem__(self, key):
method items (line 444) | def items(self):
method iteritems (line 450) | def iteritems(self):
method values (line 454) | def values(self):
method itervalue (line 458) | def itervalue(self):
method keys (line 462) | def keys(self):
method iterkeys (line 466) | def iterkeys(self):
method __reversed__ (line 474) | def __reversed__(self):
function select_autoescape (line 486) | def select_autoescape(enabled_extensions=('html', 'htm', 'xml'),
function htmlsafe_json_dumps (line 540) | def htmlsafe_json_dumps(obj, dumper=None, **kwargs):
class Cycler (line 569) | class Cycler(object):
method __init__ (line 572) | def __init__(self, *items):
method reset (line 578) | def reset(self):
method current (line 583) | def current(self):
method next (line 587) | def next(self):
class Joiner (line 596) | class Joiner(object):
method __init__ (line 599) | def __init__(self, sep=u', '):
method __call__ (line 603) | def __call__(self):
class Namespace (line 610) | class Namespace(object):
method __init__ (line 614) | def __init__(*args, **kwargs):
method __getattribute__ (line 618) | def __getattribute__(self, name):
method __setitem__ (line 626) | def __setitem__(self, name, value):
method __repr__ (line 629) | def __repr__(self):
FILE: nuitka/build/inline_copy/jinja2/jinja2/visitor.py
class NodeVisitor (line 14) | class NodeVisitor(object):
method get_visitor (line 26) | def get_visitor(self, node):
method visit (line 34) | def visit(self, node, *args, **kwargs):
method generic_visit (line 41) | def generic_visit(self, node, *args, **kwargs):
class NodeTransformer (line 47) | class NodeTransformer(NodeVisitor):
method generic_visit (line 58) | def generic_visit(self, node, *args, **kwargs):
method visit_list (line 80) | def visit_list(self, node, *args, **kwargs):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/__init__.py
function _patch_async (line 75) | def _patch_async():
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/_compat.py
function reraise (line 35) | def reraise(tp, value, tb=None):
function implements_iterator (line 69) | def implements_iterator(cls):
function implements_to_string (line 74) | def implements_to_string(cls):
function encode_filename (line 79) | def encode_filename(filename):
function with_metaclass (line 85) | def with_metaclass(meta, *bases):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/bccache.py
function marshal_dump (line 36) | def marshal_dump(code, f):
function marshal_load (line 42) | def marshal_load(f):
class Bucket (line 60) | class Bucket(object):
method __init__ (line 69) | def __init__(self, environment, key, checksum):
method reset (line 75) | def reset(self):
method load_bytecode (line 79) | def load_bytecode(self, f):
method write_bytecode (line 98) | def write_bytecode(self, f):
method bytecode_from_string (line 106) | def bytecode_from_string(self, string):
method bytecode_to_string (line 110) | def bytecode_to_string(self):
class BytecodeCache (line 117) | class BytecodeCache(object):
method load_bytecode (line 146) | def load_bytecode(self, bucket):
method dump_bytecode (line 153) | def dump_bytecode(self, bucket):
method clear (line 160) | def clear(self):
method get_cache_key (line 166) | def get_cache_key(self, name, filename=None):
method get_source_checksum (line 176) | def get_source_checksum(self, source):
method get_bucket (line 180) | def get_bucket(self, environment, name, filename, source):
method set_bucket (line 190) | def set_bucket(self, bucket):
class FileSystemBytecodeCache (line 195) | class FileSystemBytecodeCache(BytecodeCache):
method __init__ (line 213) | def __init__(self, directory=None, pattern='__jinja2_%s.cache'):
method _get_default_cache_dir (line 219) | def _get_default_cache_dir(self):
method _get_cache_filename (line 260) | def _get_cache_filename(self, bucket):
method load_bytecode (line 263) | def load_bytecode(self, bucket):
method dump_bytecode (line 271) | def dump_bytecode(self, bucket):
method clear (line 278) | def clear(self):
class MemcachedBytecodeCache (line 291) | class MemcachedBytecodeCache(BytecodeCache):
method __init__ (line 336) | def __init__(self, client, prefix='jinja2/bytecode/', timeout=None,
method load_bytecode (line 343) | def load_bytecode(self, bucket):
method dump_bytecode (line 353) | def dump_bytecode(self, bucket):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/compiler.py
function optimizeconst (line 63) | def optimizeconst(f):
function generate (line 74) | def generate(node, environment, name, filename, stream=None,
function has_safe_repr (line 87) | def has_safe_repr(value):
function find_undeclared (line 108) | def find_undeclared(nodes, names):
class MacroRef (line 121) | class MacroRef(object):
method __init__ (line 123) | def __init__(self, node):
class Frame (line 130) | class Frame(object):
method __init__ (line 133) | def __init__(self, eval_ctx, parent=None, level=None):
method copy (line 165) | def copy(self):
method inner (line 172) | def inner(self, isolated=False):
method soft (line 178) | def soft(self):
class VisitorExit (line 192) | class VisitorExit(RuntimeError):
class DependencyFinderVisitor (line 196) | class DependencyFinderVisitor(NodeVisitor):
method __init__ (line 199) | def __init__(self):
method visit_Filter (line 203) | def visit_Filter(self, node):
method visit_Test (line 207) | def visit_Test(self, node):
method visit_Block (line 211) | def visit_Block(self, node):
class UndeclaredNameVisitor (line 215) | class UndeclaredNameVisitor(NodeVisitor):
method __init__ (line 221) | def __init__(self, names):
method visit_Name (line 225) | def visit_Name(self, node):
method visit_Block (line 233) | def visit_Block(self, node):
class CompilerExit (line 237) | class CompilerExit(Exception):
class CodeGenerator (line 244) | class CodeGenerator(NodeVisitor):
method __init__ (line 246) | def __init__(self, environment, name, filename, stream=None,
method fail (line 313) | def fail(self, msg, lineno):
method temporary_identifier (line 317) | def temporary_identifier(self):
method buffer (line 322) | def buffer(self, frame):
method return_buffer_contents (line 327) | def return_buffer_contents(self, frame, force_unescaped=False):
method indent (line 345) | def indent(self):
method outdent (line 349) | def outdent(self, step=1):
method start_write (line 353) | def start_write(self, frame, node=None):
method end_write (line 360) | def end_write(self, frame):
method simple_write (line 365) | def simple_write(self, s, frame, node=None):
method blockvisit (line 371) | def blockvisit(self, nodes, frame):
method write (line 382) | def write(self, x):
method writeline (line 397) | def writeline(self, x, node=None, extra=0):
method newline (line 402) | def newline(self, node=None, extra=0):
method signature (line 409) | def signature(self, node, frame, extra_kwargs=None):
method pull_dependencies (line 462) | def pull_dependencies(self, nodes):
method enter_frame (line 475) | def enter_frame(self, frame):
method leave_frame (line 492) | def leave_frame(self, frame, with_python_scope=False):
method func (line 500) | def func(self, name):
method macro_body (line 505) | def macro_body(self, node, frame):
method macro_def (line 582) | def macro_def(self, macro_ref, frame):
method position (line 593) | def position(self, node):
method dump_local_context (line 600) | def dump_local_context(self, frame):
method write_commons (line 605) | def write_commons(self):
method push_parameter_definitions (line 614) | def push_parameter_definitions(self, frame):
method pop_parameter_definitions (line 623) | def pop_parameter_definitions(self):
method mark_parameter_stored (line 627) | def mark_parameter_stored(self, target):
method push_context_reference (line 634) | def push_context_reference(self, target):
method pop_context_reference (line 637) | def pop_context_reference(self):
method get_context_ref (line 640) | def get_context_ref(self):
method get_resolve_func (line 643) | def get_resolve_func(self):
method derive_context (line 649) | def derive_context(self, frame):
method parameter_is_undeclared (line 655) | def parameter_is_undeclared(self, target):
method push_assign_tracking (line 661) | def push_assign_tracking(self):
method pop_assign_tracking (line 665) | def pop_assign_tracking(self, frame):
method visit_Template (line 695) | def visit_Template(self, node, frame=None):
method visit_Block (line 811) | def visit_Block(self, node, frame):
method visit_Extends (line 843) | def visit_Extends(self, node, frame):
method visit_Include (line 890) | def visit_Include(self, node, frame):
method visit_Import (line 944) | def visit_Import(self, node, frame):
method visit_FromImport (line 965) | def visit_FromImport(self, node, frame):
method visit_For (line 1024) | def visit_For(self, node, frame):
method visit_If (line 1154) | def visit_If(self, node, frame):
method visit_Macro (line 1175) | def visit_Macro(self, node, frame):
method visit_CallBlock (line 1186) | def visit_CallBlock(self, node, frame):
method visit_FilterBlock (line 1194) | def visit_FilterBlock(self, node, frame):
method visit_With (line 1205) | def visit_With(self, node, frame):
method visit_ExprStmt (line 1217) | def visit_ExprStmt(self, node, frame):
method visit_Output (line 1221) | def visit_Output(self, node, frame):
method visit_Assign (line 1366) | def visit_Assign(self, node, frame):
method visit_AssignBlock (line 1374) | def visit_AssignBlock(self, node, frame):
method visit_Name (line 1399) | def visit_Name(self, node, frame):
method visit_NSRef (line 1418) | def visit_NSRef(self, node, frame):
method visit_Const (line 1430) | def visit_Const(self, node, frame):
method visit_TemplateData (line 1437) | def visit_TemplateData(self, node, frame):
method visit_Tuple (line 1444) | def visit_Tuple(self, node, frame):
method visit_List (line 1453) | def visit_List(self, node, frame):
method visit_Dict (line 1461) | def visit_Dict(self, node, frame):
method binop (line 1471) | def binop(operator, interceptable=True):
method uaop (line 1488) | def uaop(operator, interceptable=True):
method visit_Concat (line 1516) | def visit_Concat(self, node, frame):
method visit_Compare (line 1531) | def visit_Compare(self, node, frame):
method visit_Operand (line 1536) | def visit_Operand(self, node, frame):
method visit_Getattr (line 1541) | def visit_Getattr(self, node, frame):
method visit_Getitem (line 1547) | def visit_Getitem(self, node, frame):
method visit_Slice (line 1561) | def visit_Slice(self, node, frame):
method visit_Filter (line 1572) | def visit_Filter(self, node, frame):
method visit_Test (line 1604) | def visit_Test(self, node, frame):
method visit_CondExpr (line 1613) | def visit_CondExpr(self, node, frame):
method visit_Call (line 1630) | def visit_Call(self, node, frame, forward_caller=False):
method visit_Keyword (line 1644) | def visit_Keyword(self, node, frame):
method visit_MarkSafe (line 1650) | def visit_MarkSafe(self, node, frame):
method visit_MarkSafeIfAutoescape (line 1655) | def visit_MarkSafeIfAutoescape(self, node, frame):
method visit_EnvironmentAttribute (line 1660) | def visit_EnvironmentAttribute(self, node, frame):
method visit_ExtensionAttribute (line 1663) | def visit_ExtensionAttribute(self, node, frame):
method visit_ImportedName (line 1666) | def visit_ImportedName(self, node, frame):
method visit_InternalName (line 1669) | def visit_InternalName(self, node, frame):
method visit_ContextReference (line 1672) | def visit_ContextReference(self, node, frame):
method visit_Continue (line 1675) | def visit_Continue(self, node, frame):
method visit_Break (line 1678) | def visit_Break(self, node, frame):
method visit_Scope (line 1681) | def visit_Scope(self, node, frame):
method visit_OverlayScope (line 1688) | def visit_OverlayScope(self, node, frame):
method visit_EvalContextModifier (line 1702) | def visit_EvalContextModifier(self, node, frame):
method visit_ScopedEvalContextModifier (line 1713) | def visit_ScopedEvalContextModifier(self, node, frame):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/debug.py
class TracebackFrameProxy (line 36) | class TracebackFrameProxy(object):
method __init__ (line 39) | def __init__(self, tb):
method tb_next (line 44) | def tb_next(self):
method set_next (line 47) | def set_next(self, next):
method is_jinja_frame (line 59) | def is_jinja_frame(self):
method __getattr__ (line 62) | def __getattr__(self, name):
function make_frame_proxy (line 66) | def make_frame_proxy(frame):
class ProcessedTraceback (line 80) | class ProcessedTraceback(object):
method __init__ (line 83) | def __init__(self, exc_type, exc_value, frames):
method render_as_text (line 97) | def render_as_text(self, limit=None):
method render_as_html (line 103) | def render_as_html(self, full=False):
method is_template_syntax_error (line 112) | def is_template_syntax_error(self):
method exc_info (line 117) | def exc_info(self):
method standard_exc_info (line 122) | def standard_exc_info(self):
function make_traceback (line 132) | def make_traceback(exc_info, source_hint=None):
function translate_syntax_error (line 143) | def translate_syntax_error(error, source=None):
function translate_exception (line 154) | def translate_exception(exc_info, initial_skip=0):
function get_jinja_locals (line 198) | def get_jinja_locals(real_locals):
function fake_exc_info (line 228) | def fake_exc_info(exc_info, filename, lineno):
function _init_ugly_crap (line 298) | def _init_ugly_crap():
function tb_set_next (line 370) | def tb_set_next(tb, next):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/environment.py
function get_spontaneous_environment (line 44) | def get_spontaneous_environment(*args):
function create_cache (line 60) | def create_cache(size):
function copy_cache (line 69) | def copy_cache(cache):
function load_extensions (line 78) | def load_extensions(environment, extensions):
function fail_for_missing_callable (line 90) | def fail_for_missing_callable(string, name):
function _environment_sanity_check (line 100) | def _environment_sanity_check(environment):
class Environment (line 113) | class Environment(object):
method __init__ (line 264) | def __init__(self,
method add_extension (line 340) | def add_extension(self, extension):
method extend (line 347) | def extend(self, **attributes):
method overlay (line 356) | def overlay(self, block_start_string=missing, block_end_string=missing,
method iter_extensions (line 403) | def iter_extensions(self):
method getitem (line 408) | def getitem(self, obj, argument):
method getattr (line 425) | def getattr(self, obj, attribute):
method call_filter (line 438) | def call_filter(self, name, value, args=None, kwargs=None,
method call_test (line 469) | def call_test(self, name, value, args=None, kwargs=None):
method parse (line 480) | def parse(self, source, name=None, filename=None):
method _parse (line 495) | def _parse(self, source, name, filename):
method lex (line 499) | def lex(self, source, name=None, filename=None):
method preprocess (line 516) | def preprocess(self, source, name=None, filename=None):
method _tokenize (line 524) | def _tokenize(self, source, name, filename=None, state=None):
method _generate (line 536) | def _generate(self, source, name, filename, defer_init=False):
method _compile (line 545) | def _compile(self, source, filename):
method compile (line 554) | def compile(self, source, name=None, filename=None, raw=False,
method compile_expression (line 593) | def compile_expression(self, source, undefined_to_none=True):
method compile_templates (line 638) | def compile_templates(self, target, extensions=None, filter_func=None,
method list_templates (line 733) | def list_templates(self, extensions=None, filter_func=None):
method handle_exception (line 760) | def handle_exception(self, exc_info=None, rendered=False, source_hint=...
method join_path (line 782) | def join_path(self, template, parent):
method _load_template (line 795) | def _load_template(self, name, globals):
method get_template (line 810) | def get_template(self, name, parent=None, globals=None):
method select_template (line 833) | def select_template(self, names, parent=None, globals=None):
method get_or_select_template (line 860) | def get_or_select_template(self, template_name_or_list,
method from_string (line 874) | def from_string(self, source, globals=None, template_class=None):
method make_globals (line 882) | def make_globals(self, d):
class Template (line 889) | class Template(object):
method __new__ (line 919) | def __new__(cls, source,
method from_code (line 948) | def from_code(cls, environment, code, globals, uptodate=None):
method from_module_dict (line 962) | def from_module_dict(cls, environment, module_dict, globals):
method _from_namespace (line 971) | def _from_namespace(cls, environment, namespace, globals):
method render (line 993) | def render(self, *args, **kwargs):
method render_async (line 1010) | def render_async(self, *args, **kwargs):
method stream (line 1023) | def stream(self, *args, **kwargs):
method generate (line 1029) | def generate(self, *args, **kwargs):
method generate_async (line 1047) | def generate_async(self, *args, **kwargs):
method new_context (line 1055) | def new_context(self, vars=None, shared=False, locals=None):
method make_module (line 1066) | def make_module(self, vars=None, shared=False, locals=None):
method make_module_async (line 1075) | def make_module_async(self, vars=None, shared=False, locals=None):
method _get_default_module (line 1086) | def _get_default_module(self):
method module (line 1093) | def module(self):
method get_corresponding_lineno (line 1108) | def get_corresponding_lineno(self, lineno):
method is_up_to_date (line 1118) | def is_up_to_date(self):
method debug_info (line 1125) | def debug_info(self):
method __repr__ (line 1130) | def __repr__(self):
class TemplateModule (line 1139) | class TemplateModule(object):
method __init__ (line 1145) | def __init__(self, template, context, body_stream=None):
method __html__ (line 1157) | def __html__(self):
method __str__ (line 1160) | def __str__(self):
method __repr__ (line 1163) | def __repr__(self):
class TemplateExpression (line 1171) | class TemplateExpression(object):
method __init__ (line 1177) | def __init__(self, template, undefined_to_none):
method __call__ (line 1181) | def __call__(self, *args, **kwargs):
class TemplateStream (line 1191) | class TemplateStream(object):
method __init__ (line 1202) | def __init__(self, gen):
method dump (line 1206) | def dump(self, fp, encoding=None, errors='strict'):
method disable_buffering (line 1235) | def disable_buffering(self):
method _buffered_generator (line 1240) | def _buffered_generator(self, size):
method enable_buffering (line 1259) | def enable_buffering(self, size=5):
method __iter__ (line 1267) | def __iter__(self):
method __next__ (line 1270) | def __next__(self):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/exceptions.py
class TemplateError (line 14) | class TemplateError(Exception):
method __init__ (line 18) | def __init__(self, message=None):
method message (line 24) | def message(self):
method __unicode__ (line 30) | def __unicode__(self):
method __init__ (line 33) | def __init__(self, message=None):
method message (line 37) | def message(self):
class TemplateNotFound (line 45) | class TemplateNotFound(IOError, LookupError, TemplateError):
method __init__ (line 52) | def __init__(self, name, message=None):
method __str__ (line 60) | def __str__(self):
class TemplatesNotFound (line 64) | class TemplatesNotFound(TemplateNotFound):
method __init__ (line 72) | def __init__(self, names=(), message=None):
class TemplateSyntaxError (line 81) | class TemplateSyntaxError(TemplateError):
method __init__ (line 84) | def __init__(self, message, lineno, name=None, filename=None):
method __str__ (line 95) | def __str__(self):
class TemplateAssertionError (line 119) | class TemplateAssertionError(TemplateSyntaxError):
class TemplateRuntimeError (line 127) | class TemplateRuntimeError(TemplateError):
class UndefinedError (line 133) | class UndefinedError(TemplateRuntimeError):
class SecurityError (line 137) | class SecurityError(TemplateRuntimeError):
class FilterArgumentError (line 143) | class FilterArgumentError(TemplateRuntimeError):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/ext.py
class ExtensionRegistry (line 34) | class ExtensionRegistry(type):
method __new__ (line 37) | def __new__(cls, name, bases, d):
class Extension (line 43) | class Extension(with_metaclass(ExtensionRegistry, object)):
method __init__ (line 72) | def __init__(self, environment):
method bind (line 75) | def bind(self, environment):
method preprocess (line 82) | def preprocess(self, source, name, filename=None):
method filter_stream (line 89) | def filter_stream(self, stream):
method parse (line 101) | def parse(self, parser):
method attr (line 109) | def attr(self, name, lineno=None):
method call_method (line 119) | def call_method(self, name, args=None, kwargs=None, dyn_args=None,
function _gettext_alias (line 133) | def _gettext_alias(__context, *args, **kwargs):
function _make_new_gettext (line 137) | def _make_new_gettext(func):
function _make_new_ngettext (line 147) | def _make_new_ngettext(func):
class InternationalizationExtension (line 158) | class InternationalizationExtension(Extension):
method __init__ (line 169) | def __init__(self, environment):
method _install (line 181) | def _install(self, translations, newstyle=None):
method _install_null (line 190) | def _install_null(self, newstyle=None):
method _install_callables (line 197) | def _install_callables(self, gettext, ngettext, newstyle=None):
method _uninstall (line 208) | def _uninstall(self, translations):
method _extract (line 212) | def _extract(self, source, gettext_functions=GETTEXT_FUNCTIONS):
method parse (line 217) | def parse(self, parser):
method _trim_whitespace (line 322) | def _trim_whitespace(self, string, _ws_re=re.compile(r'\s*\n\s*')):
method _parse_block (line 325) | def _parse_block(self, parser, allow_pluralize):
method _make_node (line 357) | def _make_node(self, singular, plural, variables, plural_expr,
class ExprStmtExtension (line 406) | class ExprStmtExtension(Extension):
method parse (line 412) | def parse(self, parser):
class LoopControlExtension (line 418) | class LoopControlExtension(Extension):
method parse (line 422) | def parse(self, parser):
class WithExtension (line 429) | class WithExtension(Extension):
class AutoEscapeExtension (line 433) | class AutoEscapeExtension(Extension):
function extract_from_ast (line 437) | def extract_from_ast(node, gettext_functions=GETTEXT_FUNCTIONS,
class _CommentFinder (line 505) | class _CommentFinder(object):
method __init__ (line 512) | def __init__(self, tokens, comment_tags):
method find_backwards (line 518) | def find_backwards(self, offset):
method find_comments (line 533) | def find_comments(self, lineno):
function babel_extract (line 542) | def babel_extract(fileobj, keywords, comment_tags, options):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/filters.py
function contextfilter (line 29) | def contextfilter(f):
function evalcontextfilter (line 37) | def evalcontextfilter(f):
function environmentfilter (line 48) | def environmentfilter(f):
function ignore_case (line 56) | def ignore_case(value):
function make_attrgetter (line 62) | def make_attrgetter(environment, attribute, postprocess=None):
function do_forceescape (line 87) | def do_forceescape(value):
function do_urlencode (line 94) | def do_urlencode(value):
function do_replace (line 116) | def do_replace(eval_ctx, s, old, new, count=None):
function do_upper (line 143) | def do_upper(s):
function do_lower (line 148) | def do_lower(s):
function do_xmlattr (line 154) | def do_xmlattr(_eval_ctx, d, autospace=True):
function do_capitalize (line 189) | def do_capitalize(s):
function do_title (line 196) | def do_title(s):
function do_dictsort (line 206) | def do_dictsort(value, case_sensitive=False, by='key', reverse=False):
function do_sort (line 246) | def do_sort(
function do_unique (line 282) | def do_unique(environment, value, case_sensitive=False, attribute=None):
function _min_or_max (line 310) | def _min_or_max(environment, value, func, case_sensitive, attribute):
function do_min (line 326) | def do_min(environment, value, case_sensitive=False, attribute=None):
function do_max (line 341) | def do_max(environment, value, case_sensitive=False, attribute=None):
function do_default (line 355) | def do_default(value, default_value=u'', boolean=False):
function do_join (line 378) | def do_join(eval_ctx, value, d=u'', attribute=None):
function do_center (line 427) | def do_center(value, width=80):
function do_first (line 433) | def do_first(environment, seq):
function do_last (line 442) | def do_last(environment, seq):
function do_random (line 451) | def do_random(context, seq):
function do_filesizeformat (line 459) | def do_filesizeformat(value, binary=False):
function do_pprint (line 489) | def do_pprint(value, verbose=False):
function do_urlize (line 499) | def do_urlize(eval_ctx, value, trim_url_limit=None, nofollow=False,
function do_indent (line 536) | def do_indent(
function do_truncate (line 578) | def do_truncate(env, s, length=255, killwords=False, end='...', leeway=N...
function do_wordwrap (line 615) | def do_wordwrap(environment, s, width=79, break_long_words=True,
function do_wordcount (line 636) | def do_wordcount(s):
function do_int (line 641) | def do_int(value, default=0, base=10):
function do_float (line 662) | def do_float(value, default=0.0):
function do_format (line 673) | def do_format(value, *args, **kwargs):
function do_trim (line 688) | def do_trim(value):
function do_striptags (line 693) | def do_striptags(value):
function do_slice (line 701) | def do_slice(value, slices, fill_with=None):
function do_batch (line 737) | def do_batch(value, linecount, fill_with=None):
function do_round (line 768) | def do_round(value, precision=0, method='common'):
function do_groupby (line 812) | def do_groupby(environment, value, attribute):
function do_sum (line 856) | def do_sum(environment, iterable, attribute=None, start=0):
function do_list (line 876) | def do_list(value):
function do_mark_safe (line 883) | def do_mark_safe(value):
function do_mark_unsafe (line 890) | def do_mark_unsafe(value):
function do_reverse (line 895) | def do_reverse(value):
function do_attr (line 913) | def do_attr(environment, obj, name):
function do_map (line 938) | def do_map(*args, **kwargs):
function do_select (line 967) | def do_select(*args, **kwargs):
function do_reject (line 989) | def do_reject(*args, **kwargs):
function do_selectattr (line 1007) | def do_selectattr(*args, **kwargs):
function do_rejectattr (line 1028) | def do_rejectattr(*args, **kwargs):
function do_tojson (line 1047) | def do_tojson(eval_ctx, value, indent=None):
function prepare_map (line 1081) | def prepare_map(args, kwargs):
function prepare_select_or_reject (line 1103) | def prepare_select_or_reject(args, kwargs, modfunc, lookup_attr):
function select_or_reject (line 1128) | def select_or_reject(args, kwargs, modfunc, lookup_attr):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/idtracking.py
function find_symbols (line 11) | def find_symbols(nodes, parent_symbols=None):
function symbols_for_node (line 19) | def symbols_for_node(node, parent_symbols=None):
class Symbols (line 25) | class Symbols(object):
method __init__ (line 27) | def __init__(self, parent=None, level=None):
method analyze_node (line 39) | def analyze_node(self, node, **kwargs):
method _define_ref (line 43) | def _define_ref(self, name, load=None):
method find_load (line 50) | def find_load(self, target):
method find_ref (line 56) | def find_ref(self, name):
method ref (line 62) | def ref(self, name):
method copy (line 69) | def copy(self):
method store (line 77) | def store(self, name):
method declare_parameter (line 95) | def declare_parameter(self, name):
method load (line 99) | def load(self, name):
method branch_update (line 104) | def branch_update(self, branch_symbols):
method dump_stores (line 130) | def dump_stores(self):
method dump_param_targets (line 140) | def dump_param_targets(self):
class RootVisitor (line 151) | class RootVisitor(NodeVisitor):
method __init__ (line 153) | def __init__(self, symbols):
method _simple_visit (line 156) | def _simple_visit(self, node, **kwargs):
method visit_AssignBlock (line 164) | def visit_AssignBlock(self, node, **kwargs):
method visit_CallBlock (line 168) | def visit_CallBlock(self, node, **kwargs):
method visit_OverlayScope (line 172) | def visit_OverlayScope(self, node, **kwargs):
method visit_For (line 176) | def visit_For(self, node, for_branch='body', **kwargs):
method visit_With (line 192) | def visit_With(self, node, **kwargs):
method generic_visit (line 198) | def generic_visit(self, node, *args, **kwargs):
class FrameSymbolVisitor (line 203) | class FrameSymbolVisitor(NodeVisitor):
method __init__ (line 206) | def __init__(self, symbols):
method visit_Name (line 209) | def visit_Name(self, node, store_as_param=False, **kwargs):
method visit_NSRef (line 218) | def visit_NSRef(self, node, **kwargs):
method visit_If (line 221) | def visit_If(self, node, **kwargs):
method visit_Macro (line 239) | def visit_Macro(self, node, **kwargs):
method visit_Import (line 242) | def visit_Import(self, node, **kwargs):
method visit_FromImport (line 246) | def visit_FromImport(self, node, **kwargs):
method visit_Assign (line 254) | def visit_Assign(self, node, **kwargs):
method visit_For (line 259) | def visit_For(self, node, **kwargs):
method visit_CallBlock (line 265) | def visit_CallBlock(self, node, **kwargs):
method visit_FilterBlock (line 268) | def visit_FilterBlock(self, node, **kwargs):
method visit_With (line 271) | def visit_With(self, node, **kwargs):
method visit_AssignBlock (line 275) | def visit_AssignBlock(self, node, **kwargs):
method visit_Scope (line 279) | def visit_Scope(self, node, **kwargs):
method visit_Block (line 282) | def visit_Block(self, node, **kwargs):
method visit_OverlayScope (line 285) | def visit_OverlayScope(self, node, **kwargs):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/lexer.py
function _describe_token_type (line 152) | def _describe_token_type(token_type):
function describe_token (line 171) | def describe_token(token):
function describe_token_expr (line 178) | def describe_token_expr(expr):
function count_newlines (line 189) | def count_newlines(value):
function compile_rules (line 196) | def compile_rules(environment):
class Failure (line 219) | class Failure(object):
method __init__ (line 224) | def __init__(self, message, cls=TemplateSyntaxError):
method __call__ (line 228) | def __call__(self, lineno, filename):
class Token (line 232) | class Token(tuple):
method __new__ (line 237) | def __new__(cls, lineno, type, value):
method __str__ (line 240) | def __str__(self):
method test (line 247) | def test(self, expr):
method test_any (line 260) | def test_any(self, *iterable):
method __repr__ (line 267) | def __repr__(self):
class TokenStreamIterator (line 276) | class TokenStreamIterator(object):
method __init__ (line 281) | def __init__(self, stream):
method __iter__ (line 284) | def __iter__(self):
method __next__ (line 287) | def __next__(self):
class TokenStream (line 297) | class TokenStream(object):
method __init__ (line 303) | def __init__(self, generator, name, filename):
method __iter__ (line 312) | def __iter__(self):
method __bool__ (line 315) | def __bool__(self):
method push (line 321) | def push(self, token):
method look (line 325) | def look(self):
method skip (line 333) | def skip(self, n=1):
method next_if (line 338) | def next_if(self, expr):
method skip_if (line 345) | def skip_if(self, expr):
method __next__ (line 349) | def __next__(self):
method close (line 364) | def close(self):
method expect (line 370) | def expect(self, expr):
function get_lexer (line 391) | def get_lexer(environment):
class Lexer (line 412) | class Lexer(object):
method __init__ (line 420) | def __init__(self, environment):
method _normalize_newlines (line 548) | def _normalize_newlines(self, value):
method tokenize (line 552) | def tokenize(self, source, name=None, filename=None, state=None):
method wrap (line 558) | def wrap(self, stream, name=None, filename=None):
method tokeniter (line 599) | def tokeniter(self, source, name, filename=None, state=None):
FILE: nuitka/build/inline_copy/jinja2_35/jinja2/loaders.py
function split_template_path (line 22) | def split_template_path(template):
class BaseLoader (line 37) | class BaseLoader(object):
method get_source (line 70) | def get_source(self, environment, template):
method list_templates (line 93) | def list_temp
Copy disabled (too large)
Download .json
Condensed preview — 1940 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (25,095K chars).
[
{
"path": ".editorconfig",
"chars": 181,
"preview": "root = true\n\n[*.{py,c,cpp,h,rst,md,yml}]\ntrim_trailing_whitespace = true\ninsert_final_newline = true\nindent_style = spac"
},
{
"path": ".gitattributes",
"chars": 8,
"preview": "* -text\n"
},
{
"path": ".githooks/pre-commit",
"chars": 1547,
"preview": "#!/bin/sh\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#\n# An example h"
},
{
"path": ".github/FUNDING.yml",
"chars": 52,
"preview": "custom: ['https://nuitka.net/pages/donations.html']\n"
},
{
"path": ".github/ISSUE_TEMPLATE.md",
"chars": 4991,
"preview": "Before submitting an Issue, please review the\n[Issue Guidelines](https://github.com/Nuitka/Nuitka/blob/develop/CONTRIBUT"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 874,
"preview": "Thank your for contributing to Nuitka!\n\n!! Please check that you select the **develop branch** (details see below link) "
},
{
"path": ".github/workflows/testing.yml",
"chars": 6138,
"preview": "name: Nuitka tests\n# makes little sense, spell-checker: disable\non:\n pull_request:\n branches:\n - develop\n push"
},
{
"path": ".gitignore",
"chars": 910,
"preview": "*~\n*.DS_Store\n*.e4t\n*.e4q\n*.e4s\n*.pyc\n__pycache__/\n*.pyo\n*.swp\n*.swo\n*.o\n*.os\n*.so\n*.pyd\n*.pyi\n*.exe\n*.exe.away\n*.cmd\n*."
},
{
"path": ".gitmodules",
"chars": 1698,
"preview": "[submodule \"tests/CPython26\"]\n path = tests/CPython26\n url = https://github.com/Nuitka/Nuitka-CPython-tests.git\n "
},
{
"path": ".sourcery.yaml",
"chars": 897,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\nignore:\n - \"tests\"\n - \"n"
},
{
"path": ".vscode/c_cpp_properties.json",
"chars": 5959,
"preview": "{\n \"env\": {\n \"myDefaultIncludePath\": [\n \"${workspaceFolder}/nuitka/build/include\",\n \"${w"
},
{
"path": ".vscode/extensions.json",
"chars": 902,
"preview": "{\n // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.\n // Extension i"
},
{
"path": ".vscode/settings.json",
"chars": 8332,
"preview": "{\n \"files.trimTrailingWhitespace\": true,\n \"files.trimFinalNewlines\": true,\n \"C_Cpp.dimInactiveRegions\": false,\n"
},
{
"path": "CODE_OF_CONDUCT.rst",
"chars": 3441,
"preview": "######################################\n Contributor Covenant Code of Conduct\n######################################\n\n***"
},
{
"path": "CONTRIBUTING.md",
"chars": 2764,
"preview": "# Contributing to Nuitka\n\n## First things\n\nWelcome on board. Nuitka is an ambitious project. We are friendly. Join it no"
},
{
"path": "Changelog.rst",
"chars": 235,
"preview": "##################\n Nuitka Changelog\n##################\n\nIn this document, we track the per version changes and comments"
},
{
"path": "Developer_Manual.rst",
"chars": 152288,
"preview": "#########################\n Nuitka Developer Manual\n#########################\n\nThe purpose of this Developer Manual is to"
},
{
"path": "LICENSE.txt",
"chars": 11347,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "MANIFEST.in",
"chars": 1707,
"preview": "# Spell checking makes no sense, spell-checker: disable\n\ninclude LICENSE.txt\ninclude MANIFEST.in\ninclude README.rst\nincl"
},
{
"path": "README.rst",
"chars": 80796,
"preview": "####################\n Nuitka User Manual\n####################\n\nThis document is the recommended first read when you star"
},
{
"path": "SECURITY.md",
"chars": 830,
"preview": "# Security Policy\n\n## Supported Versions\n\nThere are no LTS supported versions of Nuitka, but mostly the stable version i"
},
{
"path": "Standard-Plugins-Documentation.rst",
"chars": 6791,
"preview": "#######################################\n Nuitka Standard Plugins Documentation\n#######################################\n\n"
},
{
"path": "UserPlugin-Creation.rst",
"chars": 19325,
"preview": "#############################\n How To Create a User Plugin\n#############################\n\n******************************"
},
{
"path": "Using-Plugin-Options.rst",
"chars": 1865,
"preview": "###########################\n How To Use Plugin Options\n###########################\n\n****************************\n Backgr"
},
{
"path": "bin/autoformat-nuitka-source",
"chars": 1166,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/check-nuitka-with-codespell",
"chars": 1171,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/check-nuitka-with-pylint",
"chars": 1165,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/check-nuitka-with-restlint",
"chars": 1170,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/check-nuitka-with-yamllint",
"chars": 1169,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/check-reference-counts",
"chars": 1190,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "bin/compare_with_cpython",
"chars": 1181,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "bin/compare_with_xml",
"chars": 3105,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "bin/find_sxs_modules",
"chars": 1192,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "bin/generate-specialized-c-code",
"chars": 1174,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/generate-specialized-python-code",
"chars": 1184,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/measure-construct-performance",
"chars": 1194,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "bin/nuitka",
"chars": 1716,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "bin/nuitka-run",
"chars": 1716,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "bin/nuitka-watch",
"chars": 1406,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/nuitka3",
"chars": 1240,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/nuitka3-run",
"chars": 1240,
"preview": "#!/usr/bin/env python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\""
},
{
"path": "bin/run-inside-nuitka-container",
"chars": 1171,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "debian/README.source",
"chars": 466,
"preview": "\nThe source used to build Nuitka has modifications compared to normal releases:\n\n- The benchmark programs are not includ"
},
{
"path": "debian/changelog",
"chars": 57121,
"preview": "nuitka (2.2~rc4+ds-1) unstable; urgency=medium\n\n * New upstream pre-release.\n\n -- Kay Hayen <kay.hayen@gmail.com> Sat,"
},
{
"path": "debian/compat",
"chars": 2,
"preview": "9\n"
},
{
"path": "debian/control",
"chars": 2535,
"preview": "Source: nuitka\nMaintainer: Kay Hayen <kay.hayen@gmail.com>\nSection: python\nPriority: optional\nBuild-Depends: debhelper ("
},
{
"path": "debian/copyright",
"chars": 7519,
"preview": "Format: http://svn.debian.org/wsvn/dep/web/deps/dep5.mdwn?op=file&rev=166\nUpstream-Name: nuitka\nUpstream-Contact: Kay Ha"
},
{
"path": "debian/nuitka.docs",
"chars": 10,
"preview": "changelog\n"
},
{
"path": "debian/nuitka.manpages",
"chars": 30,
"preview": "doc/nuitka.1\ndoc/nuitka-run.1\n"
},
{
"path": "debian/pbuilder-hookdir/B92test-installed-nuitka",
"chars": 1004,
"preview": "#!/bin/bash\n\n# Make sure we error exit if something goes wrong.\nset -e\n\necho \"Checking package installation and running "
},
{
"path": "debian/rules",
"chars": 1556,
"preview": "#!/usr/bin/make -f\n\nexport DH_VERBOSE = 1\nexport PYBUILD_NAME = nuitka\n\n# This disables the building with debug Python, "
},
{
"path": "debian/source/format",
"chars": 12,
"preview": "3.0 (quilt)\n"
},
{
"path": "debian/source/lintian-overrides",
"chars": 1029,
"preview": "# The build dependency on python-dev stems from the running of tests which\n# will build extensions or programs that embe"
},
{
"path": "debian/upstream-signing-key.pgp",
"chars": 3121,
"preview": "-----BEGIN PGP PUBLIC KEY BLOCK-----\nVersion: GnuPG v1.4.15 (GNU/Linux)\n\nmQINBFJ/+gwBEADG5uZfKLmI3gg2BoWd3K2C63cPMeVVVDv"
},
{
"path": "debian/watch",
"chars": 165,
"preview": "version=3\nopts=dversionmangle=s/\\+ds$//,uversionmangle=s/pre/~pre/,pgpsigurlmangle=s/$/.sig/ \\\n https://nuitka.net/rel"
},
{
"path": "doc/Doxyfile.template",
"chars": 109882,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n# Doxyfile 1.8.12\n\n# This "
},
{
"path": "doc/custom.css",
"chars": 1182,
"preview": "/**********************************************************************\n Copyright 2024, Batakrishna Sahu, mailto:<Ba"
},
{
"path": "doc/nuitka-man-include.txt",
"chars": 1919,
"preview": "[EXAMPLES]\n\nCompile a Python file \"some_module.py\" to a module \"some_module.so\":\n.IP\n\\f(CW$ nuitka \\-\\-module some_modul"
},
{
"path": "doc/nuitka-run.1",
"chars": 33696,
"preview": ".\\\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.49.1.\n.TH NUITKA-RUN \"1\" \"2024\" \"nuitka-run 2.2\" \"User Comm"
},
{
"path": "doc/nuitka.1",
"chars": 33720,
"preview": ".\\\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.49.1.\n.TH NUITKA \"1\" \"2024\" \"nuitka 2.2\" \"User Commands\"\n.S"
},
{
"path": "doc/uml/standalone-overview.plantuml",
"chars": 804,
"preview": "@startuml\n!theme spacelab\n\nrectangle \"Python Installation\" as Python {\n rectangle \"site-packages\" as sp {\n\n Re"
},
{
"path": "doc/uml/use-cases.plantuml",
"chars": 712,
"preview": "@startuml\n!theme spacelab\n\nactor user\n\nrectangle company {\n\nrectangle development {\n rectangle team {\n actor d"
},
{
"path": "lib/hints.py",
"chars": 4640,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" The hints module shou"
},
{
"path": "misc/codespell-ignore.txt",
"chars": 118,
"preview": "# kind of besides the point, spell-checker: disable\nasend\ncompiletime\n# Changelog mentions of package names\nconnexion\n"
},
{
"path": "misc/create-pbuilder-image.py",
"chars": 2405,
"preview": "#!/usr/bin/python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Sma"
},
{
"path": "misc/dump-config-options.py",
"chars": 877,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\nimport sysconfig\n\nprint(s"
},
{
"path": "misc/install-git-hooks.py",
"chars": 3651,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "misc/make-apidoc.py",
"chars": 1161,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "misc/make-coverage-rendering.py",
"chars": 2362,
"preview": "#!/usr/bin/python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\nimport "
},
{
"path": "misc/make-deb-mentors-release.py",
"chars": 1173,
"preview": "#!/usr/bin/python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" La"
},
{
"path": "misc/make-deb-release.py",
"chars": 1166,
"preview": "#!/usr/bin/python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" La"
},
{
"path": "misc/make-pypi-upload.py",
"chars": 1157,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "misc/make-release.py",
"chars": 2593,
"preview": "#!/usr/bin/python3\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Re"
},
{
"path": "misc/make-upload.py",
"chars": 2335,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "misc/make-version-bump.py",
"chars": 1165,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "misc/nuitka-package-config-schema.json",
"chars": 14240,
"preview": "{\n \"type\": \"array\",\n \"items\": {\n \"type\": \"object\",\n \"additionalProperties\": false,\n \"properti"
},
{
"path": "misc/nuitka-run.bat",
"chars": 924,
"preview": "@echo off\r\nrem Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\r\n\n\r\nsetlocal\r\n"
},
{
"path": "misc/nuitka.bat",
"chars": 1061,
"preview": "@echo off\r\nrem Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\r\n\n\r\nsetlocal\r\n"
},
{
"path": "misc/run-valgrind.py",
"chars": 2936,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "misc/update-doc.py",
"chars": 1170,
"preview": "#!/usr/bin/env python\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\""
},
{
"path": "nuitka/Builtins.py",
"chars": 7560,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Built-ins module. Inf"
},
{
"path": "nuitka/BytecodeCaching.py",
"chars": 5787,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Caching of compiled c"
},
{
"path": "nuitka/Bytecodes.py",
"chars": 3800,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Handle bytecode and c"
},
{
"path": "nuitka/CacheCleanup.py",
"chars": 1855,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Cleanup of caches for"
},
{
"path": "nuitka/Constants.py",
"chars": 11181,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Module for constants "
},
{
"path": "nuitka/Errors.py",
"chars": 2479,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" For enhanced bug repo"
},
{
"path": "nuitka/HardImportRegistry.py",
"chars": 10415,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Registry for hard imp"
},
{
"path": "nuitka/MainControl.py",
"chars": 38106,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" This is the main acti"
},
{
"path": "nuitka/ModuleRegistry.py",
"chars": 8616,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" This to keep track of"
},
{
"path": "nuitka/OptionParsing.py",
"chars": 62366,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Command line options "
},
{
"path": "nuitka/Options.py",
"chars": 75200,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Options module\n\nThis "
},
{
"path": "nuitka/OutputDirectories.py",
"chars": 5432,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Directories and paths"
},
{
"path": "nuitka/PostProcessing.py",
"chars": 15000,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Postprocessing tasks "
},
{
"path": "nuitka/Progress.py",
"chars": 6805,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Progress bars in Nuit"
},
{
"path": "nuitka/PythonFlavors.py",
"chars": 9654,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Python flavors specif"
},
{
"path": "nuitka/PythonOperators.py",
"chars": 4093,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Python operator table"
},
{
"path": "nuitka/PythonVersions.py",
"chars": 14557,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Python version specif"
},
{
"path": "nuitka/Serialization.py",
"chars": 8989,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Write and read consta"
},
{
"path": "nuitka/SourceCodeReferences.py",
"chars": 4703,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Source code reference"
},
{
"path": "nuitka/Tracing.py",
"chars": 13335,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Outputs to the user.\n"
},
{
"path": "nuitka/TreeXML.py",
"chars": 3512,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" XML node tree handlin"
},
{
"path": "nuitka/Variables.py",
"chars": 15470,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Variables link the st"
},
{
"path": "nuitka/Version.py",
"chars": 2467,
"preview": "# Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com\n#\n# Part of \"Nuitka\", an optimizing Python compiler that"
},
{
"path": "nuitka/__init__.py",
"chars": 865,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Dummy file to make th"
},
{
"path": "nuitka/__main__.py",
"chars": 6373,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\"\nThis is the main prog"
},
{
"path": "nuitka/__past__.py",
"chars": 5604,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\"\nModule like __future_"
},
{
"path": "nuitka/build/Backend.scons",
"chars": 36409,
"preview": "# -*- python -*-\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\"\nThe "
},
{
"path": "nuitka/build/CCompilerVersion.scons",
"chars": 8583,
"preview": "# -*- python -*-\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\"\nThe "
},
{
"path": "nuitka/build/DataComposerInterface.py",
"chars": 3486,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Interface to data com"
},
{
"path": "nuitka/build/Onefile.scons",
"chars": 17749,
"preview": "# -*- python -*-\n# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\"\nThe "
},
{
"path": "nuitka/build/SconsCaching.py",
"chars": 15361,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Caching of C compiler"
},
{
"path": "nuitka/build/SconsCompilerSettings.py",
"chars": 35806,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" This contains the tun"
},
{
"path": "nuitka/build/SconsHacks.py",
"chars": 5591,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Hacks for scons that "
},
{
"path": "nuitka/build/SconsInterface.py",
"chars": 17789,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Scons interface.\n\nInt"
},
{
"path": "nuitka/build/SconsProgress.py",
"chars": 2703,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Progress bar for Scon"
},
{
"path": "nuitka/build/SconsSpawn.py",
"chars": 13210,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Spawning processes.\n\n"
},
{
"path": "nuitka/build/SconsUtils.py",
"chars": 27035,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Helper functions for "
},
{
"path": "nuitka/build/__init__.py",
"chars": 865,
"preview": "# Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n\n\"\"\" Dummy file to make th"
},
{
"path": "nuitka/build/include/nuitka/allocator.h",
"chars": 8001,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_ALLOCATO"
},
{
"path": "nuitka/build/include/nuitka/builtins.h",
"chars": 3499,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_BUILTINS"
},
{
"path": "nuitka/build/include/nuitka/calling.h",
"chars": 5196,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_CALLING_"
},
{
"path": "nuitka/build/include/nuitka/checkers.h",
"chars": 2006,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_CHECKERS"
},
{
"path": "nuitka/build/include/nuitka/checksum_tools.h",
"chars": 1123,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_CHECKSUM"
},
{
"path": "nuitka/build/include/nuitka/compiled_asyncgen.h",
"chars": 9333,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_COMPILED"
},
{
"path": "nuitka/build/include/nuitka/compiled_cell.h",
"chars": 2195,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_COMPILED"
},
{
"path": "nuitka/build/include/nuitka/compiled_coroutine.h",
"chars": 9233,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_COMPILED"
},
{
"path": "nuitka/build/include/nuitka/compiled_frame.h",
"chars": 17661,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_COMPILED"
},
{
"path": "nuitka/build/include/nuitka/compiled_function.h",
"chars": 7267,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_COMPILED"
},
{
"path": "nuitka/build/include/nuitka/compiled_generator.h",
"chars": 9189,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_COMPILED"
},
{
"path": "nuitka/build/include/nuitka/compiled_method.h",
"chars": 1866,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_COMPILED"
},
{
"path": "nuitka/build/include/nuitka/constants.h",
"chars": 7620,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_CONSTANT"
},
{
"path": "nuitka/build/include/nuitka/constants_blob.h",
"chars": 1345,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_CONSTANT"
},
{
"path": "nuitka/build/include/nuitka/environment_variables.h",
"chars": 1187,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_ENVIRONM"
},
{
"path": "nuitka/build/include/nuitka/environment_variables_system.h",
"chars": 1872,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_ENVIRONM"
},
{
"path": "nuitka/build/include/nuitka/exception_groups.h",
"chars": 5302,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_EXCEPTIO"
},
{
"path": "nuitka/build/include/nuitka/exceptions.h",
"chars": 46697,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_EXCEPTIO"
},
{
"path": "nuitka/build/include/nuitka/filesystem_paths.h",
"chars": 3792,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_FILESYST"
},
{
"path": "nuitka/build/include/nuitka/freelists.h",
"chars": 6474,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_FREELIST"
},
{
"path": "nuitka/build/include/nuitka/hedley.h",
"chars": 86326,
"preview": "/* Hedley - https://nemequ.github.io/hedley\n * Created by Evan Nemerson <evan@nemerson.com>\n *\n * To the extent possible"
},
{
"path": "nuitka/build/include/nuitka/helper/attributes.h",
"chars": 3698,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_A"
},
{
"path": "nuitka/build/include/nuitka/helper/boolean.h",
"chars": 2692,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_B"
},
{
"path": "nuitka/build/include/nuitka/helper/bytearrays.h",
"chars": 1233,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_B"
},
{
"path": "nuitka/build/include/nuitka/helper/bytes.h",
"chars": 1164,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_B"
},
{
"path": "nuitka/build/include/nuitka/helper/calling_generated.h",
"chars": 11894,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/comparisons_eq.h",
"chars": 13169,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/comparisons_ge.h",
"chars": 10645,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/comparisons_gt.h",
"chars": 10644,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/comparisons_le.h",
"chars": 13169,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/comparisons_lt.h",
"chars": 13168,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/comparisons_ne.h",
"chars": 10645,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/complex.h",
"chars": 1834,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_C"
},
{
"path": "nuitka/build/include/nuitka/helper/dictionaries.h",
"chars": 13551,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_DICTIONA"
},
{
"path": "nuitka/build/include/nuitka/helper/floats.h",
"chars": 1235,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_F"
},
{
"path": "nuitka/build/include/nuitka/helper/import_hard.h",
"chars": 4401,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/indexes.h",
"chars": 1827,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_I"
},
{
"path": "nuitka/build/include/nuitka/helper/ints.h",
"chars": 3024,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_I"
},
{
"path": "nuitka/build/include/nuitka/helper/iterators.h",
"chars": 9599,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_I"
},
{
"path": "nuitka/build/include/nuitka/helper/lists.h",
"chars": 3678,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_L"
},
{
"path": "nuitka/build/include/nuitka/helper/lists_generated.h",
"chars": 1662,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/mappings.h",
"chars": 1386,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_MAPPINGS"
},
{
"path": "nuitka/build/include/nuitka/helper/operations.h",
"chars": 4671,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_OPERATIO"
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_add.h",
"chars": 12714,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_bitand.h",
"chars": 5692,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_bitor.h",
"chars": 5670,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_bitxor.h",
"chars": 5692,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_divmod.h",
"chars": 5451,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_floordiv.h",
"chars": 5489,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_lshift.h",
"chars": 5144,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_matmult.h",
"chars": 2828,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_mod.h",
"chars": 15807,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_mult.h",
"chars": 13239,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_olddiv.h",
"chars": 5820,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_pow.h",
"chars": 4743,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_rshift.h",
"chars": 5144,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_sub.h",
"chars": 5853,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_binary_truediv.h",
"chars": 5467,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_builtin_types.h",
"chars": 20173,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_add.h",
"chars": 8699,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_bitand.h",
"chars": 3796,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_bitor.h",
"chars": 3782,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_bitxor.h",
"chars": 3796,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_floordiv.h",
"chars": 4875,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_lshift.h",
"chars": 3040,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_matmult.h",
"chars": 2756,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_mod.h",
"chars": 10655,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_mult.h",
"chars": 9230,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_olddiv.h",
"chars": 5176,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_pow.h",
"chars": 4378,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_rshift.h",
"chars": 3040,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_sub.h",
"chars": 5004,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/operations_inplace_truediv.h",
"chars": 4855,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n/* WARNING, this code is "
},
{
"path": "nuitka/build/include/nuitka/helper/raising.h",
"chars": 4072,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_R"
},
{
"path": "nuitka/build/include/nuitka/helper/rangeobjects.h",
"chars": 2367,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_R"
},
{
"path": "nuitka/build/include/nuitka/helper/richcomparisons.h",
"chars": 1175,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_R"
},
{
"path": "nuitka/build/include/nuitka/helper/sequences.h",
"chars": 1141,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_S"
},
{
"path": "nuitka/build/include/nuitka/helper/sets.h",
"chars": 1054,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_SETS_H__"
},
{
"path": "nuitka/build/include/nuitka/helper/slices.h",
"chars": 8750,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_S"
},
{
"path": "nuitka/build/include/nuitka/helper/strings.h",
"chars": 1363,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_STRINGS_"
},
{
"path": "nuitka/build/include/nuitka/helper/subscripts.h",
"chars": 17975,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_S"
},
{
"path": "nuitka/build/include/nuitka/helper/tuples.h",
"chars": 5749,
"preview": "// Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file\n\n#ifndef __NUITKA_HELPER_T"
}
]
// ... and 1740 more files (download for full content)
About this extraction
This page contains the full source code of the wasmerio/py2wasm GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1940 files (22.9 MB), approximately 6.1M tokens, and a symbol index with 27961 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.