Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/containers/OrderedDicts.py

@@ -0,0 +1,191 @@
+""" This module is only an abstraction of OrderedDict as present in 2.7 and 3.x.
+
+It is not in 2.6, for this version we are using the odict.py as mentioned in the
+PEP-0372.
+
+This can be removed safely after Python2.6 support is dropped (if ever), note
+that the documentation was removed, as it's not interesting really, being
+redundant to the Python 2.7 documentation.
+
+Starting with Python 3.6, we can safely use the built-in dictionary.
+"""
+
+#    :copyright: (c) 2008 by Armin Ronacher and PEP 273 authors.
+#    :license: modified BSD license.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of the <organization> nor the
+#       names of its contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Kay Hayen did some changes for Nuitka, and put everything he added under the same
+# modified BSD license.
+
+from nuitka.PythonVersions import python_version
+
+try:
+    if python_version >= 0x360:
+        OrderedDict = dict
+    else:
+        from collections import OrderedDict
+
+except ImportError:
+    # This is for Python 2.6 only.
+    # pylint: disable=I0021,protected-access,undefined-variable
+
+    assert python_version < 0x270
+
+    from copy import deepcopy
+    from itertools import imap, izip
+
+    missing = object()
+
+    class OrderedDict(dict):
+        def __init__(self, *args, **kwargs):
+            dict.__init__(self)
+            self._keys = []
+            self.update(*args, **kwargs)
+
+        def __delitem__(self, key):
+            dict.__delitem__(self, key)
+            self._keys.remove(key)
+
+        def __setitem__(self, key, item):
+            if key not in self:
+                self._keys.append(key)
+            dict.__setitem__(self, key, item)
+
+        def __deepcopy__(self, memo=None):
+            if memo is None:
+                memo = {}
+            d = memo.get(id(self), missing)
+            if d is not missing:
+                return d
+            memo[id(self)] = d = self.__class__()
+            dict.__init__(d, deepcopy(self.items(), memo))
+            d._keys = self._keys[:]
+            return d
+
+        def __getstate__(self):
+            return {"items": dict(self), "keys": self._keys}
+
+        def __setstate__(self, d):
+            self._keys = d["keys"]
+            dict.update(d["items"])
+
+        def __reversed__(self):
+            return reversed(self._keys)
+
+        def __eq__(self, other):
+            if isinstance(other, OrderedDict):
+                if not dict.__eq__(self, other):
+                    return False
+                return self.items() == other.items()
+            return dict.__eq__(self, other)
+
+        def __ne__(self, other):
+            return not self.__eq__(other)
+
+        def __cmp__(self, other):
+            if isinstance(other, OrderedDict):
+                return cmp(self.items(), other.items())
+            elif isinstance(other, dict):
+                return dict.__cmp__(self, other)
+            return NotImplemented
+
+        @classmethod
+        def fromkeys(cls, iterable, default=None):
+            return cls((key, default) for key in iterable)
+
+        def clear(self):
+            del self._keys[:]
+            dict.clear(self)
+
+        def copy(self):
+            return self.__class__(self)
+
+        def items(self):
+            return zip(self._keys, self.values())
+
+        def iteritems(self):
+            return izip(self._keys, self.itervalues())
+
+        def keys(self):
+            return self._keys[:]
+
+        def iterkeys(self):
+            return iter(self._keys)
+
+        def pop(self, key, default=missing):
+            if default is missing:
+                return dict.pop(self, key)
+            elif key not in self:
+                return default
+            self._keys.remove(key)
+            return dict.pop(self, key, default)
+
+        def popitem(self, key):
+            self._keys.remove(key)
+            return dict.popitem(key)
+
+        def setdefault(self, key, default=None):
+            if key not in self:
+                self._keys.append(key)
+            dict.setdefault(self, key, default)
+
+        def update(self, *args, **kwargs):
+            sources = []
+            if len(args) == 1:
+                if hasattr(args[0], "iteritems"):
+                    sources.append(args[0].iteritems())
+                else:
+                    sources.append(iter(args[0]))
+            elif args:
+                raise TypeError("expected at most one positional argument")
+            if kwargs:
+                sources.append(kwargs.iteritems())
+            for iterable in sources:
+                for key, val in iterable:
+                    self[key] = val
+
+        def values(self):
+            return map(self.get, self._keys)
+
+        def itervalues(self):
+            return imap(self.get, self._keys)
+
+        def index(self, item):
+            return self._keys.index(item)
+
+        def byindex(self, item):
+            key = self._keys[item]
+            return (key, dict.__getitem__(self, key))
+
+        def reverse(self):
+            self._keys.reverse()
+
+        def sort(self, *args, **kwargs):
+            self._keys.sort(*args, **kwargs)
+
+        def __repr__(self):
+            return "OrderedDict(%r)" % self.items()
+
+        __copy__ = copy
+        __iter__ = iterkeys

nuitka/containers/OrderedSets.py

@@ -0,0 +1,123 @@
+""" This module is only an abstraction of OrderedSet which is not present in
+Python at all.
+
+spell-checker: ignore orderedset,orderedsets
+
+"""
+
+import os
+import subprocess
+import sys
+
+from nuitka.PythonVersions import python_version
+from nuitka.utils.InlineCopies import getDownloadCopyFolder
+
+recommended_orderedset_package_name, recommended_orderedset_module_name = (
+    ("ordered-set", "ordered_set")
+    if python_version >= 0x370
+    else ("orderedset", "orderedsets")
+)
+
+
+def _tryImportOrderedSet():
+    try:
+        from orderedset import OrderedSet as result
+    except ImportError:
+        try:
+            from ordered_set import OrderedSet as result
+        except ImportError:
+            return None
+
+    return result
+
+
+OrderedSet = _tryImportOrderedSet()
+
+
+def _findDownloadSitePackagesDir(download_folder):
+    for root, dirnames, _filenames in os.walk(download_folder):
+        found_candidate = None
+        for candidate in ("site-packages", "dist-packages", "vendor-packages"):
+            if candidate in dirnames:
+                # Unclear which one to use.
+                if found_candidate is not None:
+                    return
+
+                found_candidate = candidate
+
+        if found_candidate:
+            return os.path.join(root, found_candidate)
+
+
+def tryDownloadPackageName(package_name, module_name, package_version):
+    download_folder = getDownloadCopyFolder()
+
+    site_packages_folder = _findDownloadSitePackagesDir(download_folder)
+
+    if site_packages_folder is not None:
+        candidate = os.path.join(site_packages_folder, module_name)
+
+        if os.path.exists(candidate):
+            return site_packages_folder
+
+    if os.getenv("NUITKA_ASSUME_YES_FOR_DOWNLOADS") in ("1", "true", "yes"):
+        if package_version is not None:
+            package_spec = "%s==%s" % (package_name, package_version)
+        else:
+            package_spec = package_name
+
+        exit_code = subprocess.call(
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "--root",
+                download_folder,
+                package_spec,
+            ],
+            shell=False,
+        )
+
+        if exit_code != 0:
+            return None
+
+        if site_packages_folder is None:
+            site_packages_folder = _findDownloadSitePackagesDir(download_folder)
+
+    if site_packages_folder is not None:
+        candidate = os.path.join(site_packages_folder, module_name)
+
+        if os.path.exists(candidate):
+            return site_packages_folder
+
+
+def _tryDownloadOrderedSet():
+    return tryDownloadPackageName(
+        recommended_orderedset_package_name,
+        recommended_orderedset_module_name,
+        package_version=None,
+    )
+
+
+if OrderedSet is None:
+    downloaded_pip = _tryDownloadOrderedSet()
+
+    try:
+        sys.path.insert(0, downloaded_pip)
+        OrderedSet = _tryImportOrderedSet()
+    finally:
+        del sys.path[0]
+
+    if OrderedSet is None:
+        from .OrderedSetsFallback import OrderedSet
+
+
+def buildOrderedSet(*producers):
+    """Helper function to merge multiple producers into one OrderedSet value"""
+    values = []
+
+    for producer in producers:
+        values.extend(producer)
+
+    return OrderedSet(values)

nuitka/containers/OrderedSetsFallback.py

@@ -0,0 +1,139 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" This module is only an abstraction of OrderedSet which is not present in
+Python at all.
+
+It was originally downloaded from http://code.activestate.com/recipes/576694/
+"""
+
+# Copyright 2009 Raymond Hettinger
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# Note: Kay Hayen did some changes for Nuitka keeping this license. These
+# changes are not improvements, use the original source instead, not this
+# file.
+
+# pylint: disable=redefined-builtin
+
+from nuitka.__past__ import MutableSet
+
+
+class OrderedSet(MutableSet):
+    is_fallback = True
+
+    def __init__(self, iterable=()):
+        self.end = end = []
+        end += (None, end, end)  # sentinel node for doubly linked list
+        self.map = {}  # key --> [key, prev, next]
+        if iterable:
+            self |= iterable
+
+    def __len__(self):
+        return len(self.map)
+
+    def __contains__(self, key):
+        return key in self.map
+
+    def add(self, key):
+        if key not in self.map:
+            end = self.end
+            curr = end[1]
+            curr[2] = end[1] = self.map[key] = [key, curr, end]
+
+    def update(self, keys):
+        for key in keys:
+            self.add(key)
+
+    def discard(self, key):
+        if key in self.map:
+            key, prev, next = self.map.pop(key)
+            prev[2] = next
+            next[1] = prev
+
+    def __iter__(self):
+        end = self.end
+        curr = end[2]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[2]
+
+    def __reversed__(self):
+        end = self.end
+        curr = end[1]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[1]
+
+    def pop(self, last=True):
+        if not self:
+            raise KeyError("set is empty")
+        key = self.end[1][0] if last else self.end[2][0]
+        self.discard(key)
+        return key
+
+    def __repr__(self):
+        if not self:
+            return "%s()" % (self.__class__.__name__,)
+        return "%s(%r)" % (self.__class__.__name__, list(self))
+
+    def __eq__(self, other):
+        if isinstance(other, OrderedSet):
+            return len(self) == len(other) and list(self) == list(other)
+        return set(self) == set(other)
+
+    def union(self, iterable):
+        result = OrderedSet(self)
+
+        for key in iterable:
+            result.add(key)
+
+        return result
+
+    def index(self, key):
+        if key in self.map:
+            end = self.end
+            curr = self.map[key]
+
+            count = 0
+            while curr is not end:
+                curr = curr[1]
+                count += 1
+
+            return count - 1
+
+        return None
+
+
+#     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.

nuitka/containers/__init__.py

@@ -0,0 +1,19 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
+#     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.

nuitka/distutils/Build.py

@@ -0,0 +1,76 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nuitka python -m build integration """
+
+import contextlib
+import os
+
+import setuptools.build_meta
+
+if not hasattr(setuptools.build_meta, "suppress_known_deprecation"):
+
+    @contextlib.contextmanager
+    def suppress_known_deprecation():
+        yield
+
+else:
+    suppress_known_deprecation = setuptools.build_meta.suppress_known_deprecation
+
+
+# reusing private "build" package code, pylint: disable=protected-access
+class NuitkaBuildMetaBackend(setuptools.build_meta._BuildMetaBackend):
+    def build_wheel(
+        self, wheel_directory, config_settings=None, metadata_directory=None
+    ):
+        # Allow falling back to setuptools when the `build_with_nuitka` configuration setting is set to true.
+        if config_settings:
+            build_with_nuitka = config_settings.pop("build_with_nuitka", "true").lower()
+
+            if build_with_nuitka not in ("true", "false"):
+                raise ValueError(
+                    "When passing the 'build_with_nuitka' setting, it must either be 'true' or 'false'."
+                )
+
+            if build_with_nuitka == "false":
+                return super().build_wheel(
+                    wheel_directory, config_settings, metadata_directory
+                )
+
+        os.environ["NUITKA_TOML_FILE"] = os.path.join(os.getcwd(), "pyproject.toml")
+
+        with suppress_known_deprecation():
+            return self._build_with_temp_dir(
+                ["bdist_nuitka"], ".whl", wheel_directory, config_settings
+            )
+
+
+_BACKEND = NuitkaBuildMetaBackend()
+
+get_requires_for_build_wheel = _BACKEND.get_requires_for_build_wheel
+get_requires_for_build_sdist = _BACKEND.get_requires_for_build_sdist
+prepare_metadata_for_build_wheel = _BACKEND.prepare_metadata_for_build_wheel
+build_wheel = _BACKEND.build_wheel
+build_sdist = _BACKEND.build_sdist
+
+LEGACY_EDITABLE = getattr(setuptools.build_meta, "LEGACY_EDITABLE", False)
+
+if not LEGACY_EDITABLE:
+    get_requires_for_build_editable = _BACKEND.get_requires_for_build_editable
+    prepare_metadata_for_build_editable = _BACKEND.prepare_metadata_for_build_editable
+    build_editable = _BACKEND.build_editable
+
+#     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.