Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-27 02:38
📄 __init__.py """Extensions to the 'distutils' for large or complex distributions""" # mypy: disable_error_code=override # Command.reinitialize_command has an extra *kw param that distutils doesn't have # Can't disable on the exact line because distutils doesn't exists on Python 3.12 # and mypy isn't aware of distutils_hack, causing distutils.core.Command to be Any, # and a [unused-ignore] to be raised on 3.12+ from __future__ import annotations import functools import os import sys from abc import abstractmethod from collections.abc import Mapping from typing import TYPE_CHECKING, TypeVar, overload sys.path.extend(((vendor_path := os.path.join(os.path.dirname(os.path.dirname(__file__)), 'setuptools', '_vendor')) not in sys.path) [vendor_path]) # fmt: skip # workaround for #4476 sys.modules.pop('backports', None) import _distutils_hack.override # noqa: F401 from . import logging, monkey from .depends import Require from .discovery import PackageFinder, PEP420PackageFinder from .dist import Distribution from .extension import Extension from .version import __version__ as __version__ from .warnings import SetuptoolsDeprecationWarning import distutils.core __all__ = [ 'setup', 'Distribution', 'Command', 'Extension', 'Require', 'SetuptoolsDeprecationWarning', 'find_packages', 'find_namespace_packages', ] _CommandT = TypeVar("_CommandT", bound="_Command") bootstrap_install_from = None find_packages = PackageFinder.find find_namespace_packages = PEP420PackageFinder.find def _install_setup_requires(attrs): # Note: do not use `setuptools.Distribution` directly, as # our PEP 517 backend patch `distutils.core.Distribution`. class MinimalDistribution(distutils.core.Distribution): """ A minimal version of a distribution for supporting the fetch_build_eggs interface. """ def __init__(self, attrs: Mapping[str, object]) -> None: _incl = 'dependency_links', 'setup_requires' filtered = {k: attrs[k] for k in set(_incl) & set(attrs)} super().__init__(filtered) # Prevent accidentally triggering discovery with incomplete set of attrs self.set_defaults._disable() def _get_project_config_files(self, filenames=None): """Ignore ``pyproject.toml``, they are not related to setup_requires""" try: cfg, _toml = super()._split_standard_project_metadata(filenames) except Exception: return filenames, () return cfg, () def finalize_options(self): """ Disable finalize_options to avoid building the working set. Ref #2158. """ dist = MinimalDistribution(attrs) # Honor setup.cfg's options. dist.parse_config_files(ignore_option_errors=True) if dist.setup_requires: _fetch_build_eggs(dist) def _fetch_build_eggs(dist: Distribution): try: dist.fetch_build_eggs(dist.setup_requires) except Exception as ex: msg = """ It is possible a package already installed in your system contains an version that is invalid according to PEP 440. You can try `pip install --use-pep517` as a workaround for this problem, or rely on a new virtual environment. If the problem refers to a package that is not installed yet, please contact that package's maintainers or distributors. """ if "InvalidVersion" in ex.__class__.__name__: if hasattr(ex, "add_note"): ex.add_note(msg) # PEP 678 else: dist.announce(f"\n{msg}\n") raise def setup(attrs): logging.configure() # Make sure we have any requirements needed to interpret 'attrs'. _install_setup_requires(attrs) return distutils.core.setup(attrs) setup.__doc__ = distutils.core.setup.__doc__ if TYPE_CHECKING: # Work around a mypy issue where type[T] can't be used as a base: https://github.com/python/mypy/issues/10962 from distutils.core import Command as _Command else: _Command = monkey.get_unpatched(distutils.core.Command) class Command(_Command): """ Setuptools internal actions are organized using a command design pattern. This means that each action (or group of closely related actions) executed during the build should be implemented as a ``Command`` subclass. These commands are abstractions and do not necessarily correspond to a command that can (or should) be executed via a terminal, in a CLI fashion (although historically they would). When creating a new command from scratch, custom defined classes SHOULD inherit from ``setuptools.Command`` and implement a few mandatory methods. Between these mandatory methods, are listed: :meth:`initialize_options`, :meth:`finalize_options` and :meth:`run`. A useful analogy for command classes is to think of them as subroutines with local variables called "options". The options are "declared" in :meth:`initialize_options` and "defined" (given their final values, aka "finalized") in :meth:`finalize_options`, both of which must be defined by every command class. The "body" of the subroutine, (where it does all the work) is the :meth:`run` method. Between :meth:`initialize_options` and :meth:`finalize_options`, ``setuptools`` may set the values for options/attributes based on user's input (or circumstance), which means that the implementation should be careful to not overwrite values in :meth:`finalize_options` unless necessary. Please note that other commands (or other parts of setuptools) may also overwrite the values of the command's options/attributes multiple times during the build process. Therefore it is important to consistently implement :meth:`initialize_options` and :meth:`finalize_options`. For example, all derived attributes (or attributes that depend on the value of other attributes) SHOULD be recomputed in :meth:`finalize_options`. When overwriting existing commands, custom defined classes MUST abide by the same APIs implemented by the original class. They also SHOULD inherit from the original class. """ command_consumes_arguments = False distribution: Distribution # override distutils.dist.Distribution with setuptools.dist.Distribution def __init__(self, dist: Distribution, kw) -> None: """ Construct the command for dist, updating vars(self) with any keyword parameters. """ super().__init__(dist) vars(self).update(kw) @overload def reinitialize_command( self, command: str, reinit_subcommands: bool = False, kw ) -> _Command: ... @overload def reinitialize_command( self, command: _CommandT, reinit_subcommands: bool = False, kw ) -> _CommandT: ... def reinitialize_command( self, command: str \| _Command, reinit_subcommands: bool = False, kw ) -> _Command: cmd = _Command.reinitialize_command(self, command, reinit_subcommands) vars(cmd).update(kw) return cmd # pyright: ignore[reportReturnType] # pypa/distutils#307 @abstractmethod def initialize_options(self) -> None: """ Set or (reset) all options/attributes/caches used by the command to their default values. Note that these values may be overwritten during the build. """ raise NotImplementedError @abstractmethod def finalize_options(self) -> None: """ Set final values for all options/attributes used by the command. Most of the time, each option/attribute/cache should only be set if it does not have any value yet (e.g. ``if self.attr is None: self.attr = val``). """ raise NotImplementedError @abstractmethod def run(self) -> None: """ Execute the actions intended by the command. (Side effects SHOULD only take place when :meth:`run` is executed, for example, creating new files or writing to the terminal output). """ raise NotImplementedError def _find_all_simple(path): """ Find all files under 'path' """ results = ( os.path.join(base, file) for base, dirs, files in os.walk(path, followlinks=True) for file in files ) return filter(os.path.isfile, results) def findall(dir=os.curdir): """ Find all files under 'dir' and return the list of full filenames. Unless dir is '.', return full filenames with dir prepended. """ files = _find_all_simple(dir) if dir == os.curdir: make_rel = functools.partial(os.path.relpath, start=dir) files = map(make_rel, files) return list(files) class sic(str): """Treat this string as-is (https://en.wikipedia.org/wiki/Sic)""" # Apply monkey patches monkey.patch_all()	8.79 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:56
📄 _core_metadata.py """ Handling of Core Metadata for Python packages (including reading and writing). See: https://packaging.python.org/en/latest/specifications/core-metadata/ """ from __future__ import annotations import os import stat import textwrap from email import message_from_file from email.message import Message from tempfile import NamedTemporaryFile from packaging.markers import Marker from packaging.requirements import Requirement from packaging.utils import canonicalize_name, canonicalize_version from packaging.version import Version from . import _normalization, _reqs from ._static import is_static from .warnings import SetuptoolsDeprecationWarning from distutils.util import rfc822_escape def get_metadata_version(self): mv = getattr(self, 'metadata_version', None) if mv is None: mv = Version('2.4') self.metadata_version = mv return mv def rfc822_unescape(content: str) -> str: """Reverse RFC-822 escaping by removing leading whitespaces from content.""" lines = content.splitlines() if len(lines) == 1: return lines[0].lstrip() return '\n'.join((lines[0].lstrip(), textwrap.dedent('\n'.join(lines[1:])))) def _read_field_from_msg(msg: Message, field: str) -> str \| None: """Read Message header field.""" value = msg[field] if value == 'UNKNOWN': return None return value def _read_field_unescaped_from_msg(msg: Message, field: str) -> str \| None: """Read Message header field and apply rfc822_unescape.""" value = _read_field_from_msg(msg, field) if value is None: return value return rfc822_unescape(value) def _read_list_from_msg(msg: Message, field: str) -> list[str] \| None: """Read Message header field and return all results as list.""" values = msg.get_all(field, None) if values == []: return None return values def _read_payload_from_msg(msg: Message) -> str \| None: value = str(msg.get_payload()).strip() if value == 'UNKNOWN' or not value: return None return value def read_pkg_file(self, file): """Reads the metadata values from a file object.""" msg = message_from_file(file) self.metadata_version = Version(msg['metadata-version']) self.name = _read_field_from_msg(msg, 'name') self.version = _read_field_from_msg(msg, 'version') self.description = _read_field_from_msg(msg, 'summary') # we are filling author only. self.author = _read_field_from_msg(msg, 'author') self.maintainer = None self.author_email = _read_field_from_msg(msg, 'author-email') self.maintainer_email = None self.url = _read_field_from_msg(msg, 'home-page') self.download_url = _read_field_from_msg(msg, 'download-url') self.license = _read_field_unescaped_from_msg(msg, 'license') self.license_expression = _read_field_unescaped_from_msg(msg, 'license-expression') self.long_description = _read_field_unescaped_from_msg(msg, 'description') if self.long_description is None and self.metadata_version >= Version('2.1'): self.long_description = _read_payload_from_msg(msg) self.description = _read_field_from_msg(msg, 'summary') if 'keywords' in msg: self.keywords = _read_field_from_msg(msg, 'keywords').split(',') self.platforms = _read_list_from_msg(msg, 'platform') self.classifiers = _read_list_from_msg(msg, 'classifier') # PEP 314 - these fields only exist in 1.1 if self.metadata_version == Version('1.1'): self.requires = _read_list_from_msg(msg, 'requires') self.provides = _read_list_from_msg(msg, 'provides') self.obsoletes = _read_list_from_msg(msg, 'obsoletes') else: self.requires = None self.provides = None self.obsoletes = None self.license_files = _read_list_from_msg(msg, 'license-file') def single_line(val): """ Quick and dirty validation for Summary pypa/setuptools#1390. """ if '\n' in val: # TODO: Replace with `raise ValueError("newlines not allowed")` # after reviewing #2893. msg = "newlines are not allowed in `summary` and will break in the future" SetuptoolsDeprecationWarning.emit("Invalid config.", msg) # due_date is undefined. Controversial change, there was a lot of push back. val = val.strip().split('\n')[0] return val def write_pkg_info(self, base_dir): """Write the PKG-INFO file into the release tree.""" temp = "" final = os.path.join(base_dir, 'PKG-INFO') try: # Use a temporary file while writing to avoid race conditions # (e.g. `importlib.metadata` reading `.egg-info/PKG-INFO`): with NamedTemporaryFile("w", encoding="utf-8", dir=base_dir, delete=False) as f: temp = f.name self.write_pkg_file(f) permissions = stat.S_IMODE(os.lstat(temp).st_mode) os.chmod(temp, permissions \| stat.S_IRGRP \| stat.S_IROTH) os.replace(temp, final) # atomic operation. finally: if temp and os.path.exists(temp): os.remove(temp) # Based on Python 3.5 version def write_pkg_file(self, file): # noqa: C901 # is too complex (14) # FIXME """Write the PKG-INFO format data to a file object.""" version = self.get_metadata_version() def write_field(key, value): file.write(f"{key}: {value}\n") write_field('Metadata-Version', str(version)) write_field('Name', self.get_name()) write_field('Version', self.get_version()) summary = self.get_description() if summary: write_field('Summary', single_line(summary)) optional_fields = ( ('Home-page', 'url'), ('Download-URL', 'download_url'), ('Author', 'author'), ('Author-email', 'author_email'), ('Maintainer', 'maintainer'), ('Maintainer-email', 'maintainer_email'), ) for field, attr in optional_fields: attr_val = getattr(self, attr, None) if attr_val is not None: write_field(field, attr_val) if license_expression := self.license_expression: write_field('License-Expression', license_expression) elif license := self.get_license(): write_field('License', rfc822_escape(license)) for label, url in self.project_urls.items(): write_field('Project-URL', f'{label}, {url}') keywords = ','.join(self.get_keywords()) if keywords: write_field('Keywords', keywords) platforms = self.get_platforms() or [] for platform in platforms: write_field('Platform', platform) self._write_list(file, 'Classifier', self.get_classifiers()) # PEP 314 self._write_list(file, 'Requires', self.get_requires()) self._write_list(file, 'Provides', self.get_provides()) self._write_list(file, 'Obsoletes', self.get_obsoletes()) # Setuptools specific for PEP 345 if hasattr(self, 'python_requires'): write_field('Requires-Python', self.python_requires) # PEP 566 if self.long_description_content_type: write_field('Description-Content-Type', self.long_description_content_type) safe_license_files = map(_safe_license_file, self.license_files or []) self._write_list(file, 'License-File', safe_license_files) _write_requirements(self, file) for field, attr in _POSSIBLE_DYNAMIC_FIELDS.items(): if (val := getattr(self, attr, None)) and not is_static(val): write_field('Dynamic', field) long_description = self.get_long_description() if long_description: file.write(f"\n{long_description}") if not long_description.endswith("\n"): file.write("\n") def _write_requirements(self, file): for req in _reqs.parse(self.install_requires): file.write(f"Requires-Dist: {req}\n") processed_extras = {} for augmented_extra, reqs in self.extras_require.items(): # Historically, setuptools allows "augmented extras": `<extra>:<condition>` unsafe_extra, _, condition = augmented_extra.partition(":") unsafe_extra = unsafe_extra.strip() extra = _normalization.safe_extra(unsafe_extra) if extra: _write_provides_extra(file, processed_extras, extra, unsafe_extra) for req in _reqs.parse_strings(reqs): r = _include_extra(req, extra, condition.strip()) file.write(f"Requires-Dist: {r}\n") return processed_extras def _include_extra(req: str, extra: str, condition: str) -> Requirement: r = Requirement(req) # create a fresh object that can be modified parts = ( f"({r.marker})" if r.marker else None, f"({condition})" if condition else None, f"extra == {extra!r}" if extra else None, ) r.marker = Marker(" and ".join(x for x in parts if x)) return r def _write_provides_extra(file, processed_extras, safe, unsafe): previous = processed_extras.get(safe) if previous == unsafe: SetuptoolsDeprecationWarning.emit( 'Ambiguity during "extra" normalization for dependencies.', f""" {previous!r} and {unsafe!r} normalize to the same value:\n {safe!r}\n In future versions, setuptools might halt the build process. """, see_url="https://peps.python.org/pep-0685/", ) else: processed_extras[safe] = unsafe file.write(f"Provides-Extra: {safe}\n") # from pypa/distutils#244; needed only until that logic is always available def get_fullname(self): return _distribution_fullname(self.get_name(), self.get_version()) def _distribution_fullname(name: str, version: str) -> str: """ >>> _distribution_fullname('setup.tools', '1.0-2') 'setup_tools-1.0.post2' >>> _distribution_fullname('setup-tools', '1.2post2') 'setup_tools-1.2.post2' >>> _distribution_fullname('setup-tools', '1.0-r2') 'setup_tools-1.0.post2' >>> _distribution_fullname('setup.tools', '1.0.post') 'setup_tools-1.0.post0' >>> _distribution_fullname('setup.tools', '1.0+ubuntu-1') 'setup_tools-1.0+ubuntu.1' """ return "{}-{}".format( canonicalize_name(name).replace('-', '_'), canonicalize_version(version, strip_trailing_zero=False), ) def _safe_license_file(file): # XXX: Do we need this after the deprecation discussed in #4892, #4896?? normalized = os.path.normpath(file).replace(os.sep, "/") if "../" in normalized: return os.path.basename(normalized) # Temporarily restore pre PEP639 behaviour return normalized _POSSIBLE_DYNAMIC_FIELDS = { # Core Metadata Field x related Distribution attribute "author": "author", "author-email": "author_email", "classifier": "classifiers", "description": "long_description", "description-content-type": "long_description_content_type", "download-url": "download_url", "home-page": "url", "keywords": "keywords", "license": "license", # XXX: License-File is complicated because the user gives globs that are expanded # during the build. Without special handling it is likely always # marked as Dynamic, which is an acceptable outcome according to: # https://github.com/pypa/setuptools/issues/4629#issuecomment-2331233677 "license-file": "license_files", "license-expression": "license_expression", # PEP 639 "maintainer": "maintainer", "maintainer-email": "maintainer_email", "obsoletes": "obsoletes", # "obsoletes-dist": "obsoletes_dist", # NOT USED "platform": "platforms", "project-url": "project_urls", "provides": "provides", # "provides-dist": "provides_dist", # NOT USED "provides-extra": "extras_require", "requires": "requires", "requires-dist": "install_requires", # "requires-external": "requires_external", # NOT USED "requires-python": "python_requires", "summary": "description", # "supported-platform": "supported_platforms", # NOT USED }	11.7 KB	2026-01-20 12:58
📄 _discovery.py import functools import operator import packaging.requirements # from coherent.build.discovery def extras_from_dep(dep): try: markers = packaging.requirements.Requirement(dep).marker._markers except AttributeError: markers = () return set( marker[2].value for marker in markers if isinstance(marker, tuple) and marker[0].value == 'extra' ) def extras_from_deps(deps): """ >>> extras_from_deps(['requests']) set() >>> extras_from_deps(['pytest; extra == "test"']) {'test'} >>> sorted(extras_from_deps([ ... 'requests', ... 'pytest; extra == "test"', ... 'pytest-cov; extra == "test"', ... 'sphinx; extra=="doc"'])) ['doc', 'test'] """ return functools.reduce(operator.or_, map(extras_from_dep, deps), set())	836 B	2026-01-20 12:58
📁 _distutils	-	2026-03-21 15:45
📄 _entry_points.py import functools import itertools import operator from jaraco.functools import pass_none from jaraco.text import yield_lines from more_itertools import consume from ._importlib import metadata from ._itertools import ensure_unique from .errors import OptionError def ensure_valid(ep): """ Exercise one of the dynamic properties to trigger the pattern match. This function is deprecated in favor of importlib_metadata 8.7 and Python 3.14 importlib.metadata, which validates entry points on construction. """ try: ep.extras except (AttributeError, AssertionError) as ex: # Why both? See https://github.com/python/importlib_metadata/issues/488 msg = ( f"Problems to parse {ep}.\nPlease ensure entry-point follows the spec: " "https://packaging.python.org/en/latest/specifications/entry-points/" ) raise OptionError(msg) from ex def load_group(value, group): """ Given a value of an entry point or series of entry points, return each as an EntryPoint. """ # normalize to a single sequence of lines lines = yield_lines(value) text = f'[{group}]\n' + '\n'.join(lines) return metadata.EntryPoints._from_text(text) def by_group_and_name(ep): return ep.group, ep.name def validate(eps: metadata.EntryPoints): """ Ensure entry points are unique by group and name and validate each. """ consume(map(ensure_valid, ensure_unique(eps, key=by_group_and_name))) return eps @functools.singledispatch def load(eps): """ Given a Distribution.entry_points, produce EntryPoints. """ groups = itertools.chain.from_iterable( load_group(value, group) for group, value in eps.items() ) return validate(metadata.EntryPoints(groups)) @load.register(str) def _(eps): r""" >>> ep, = load('[console_scripts]\nfoo=bar') >>> ep.group 'console_scripts' >>> ep.name 'foo' >>> ep.value 'bar' """ return validate(metadata.EntryPoints(metadata.EntryPoints._from_text(eps))) load.register(type(None), lambda x: x) @pass_none def render(eps: metadata.EntryPoints): by_group = operator.attrgetter('group') groups = itertools.groupby(sorted(eps, key=by_group), by_group) return '\n'.join(f'[{group}]\n{render_items(items)}\n' for group, items in groups) def render_items(eps): return '\n'.join(f'{ep.name} = {ep.value}' for ep in sorted(eps))	2.41 KB	2026-01-20 12:58
📄 _imp.py """ Re-implementation of find_module and get_frozen_object from the deprecated imp module. """ import importlib.machinery import importlib.util import os import tokenize from importlib.util import module_from_spec PY_SOURCE = 1 PY_COMPILED = 2 C_EXTENSION = 3 C_BUILTIN = 6 PY_FROZEN = 7 def find_spec(module, paths): finder = ( importlib.machinery.PathFinder().find_spec if isinstance(paths, list) else importlib.util.find_spec ) return finder(module, paths) def find_module(module, paths=None): """Just like 'imp.find_module()', but with package support""" spec = find_spec(module, paths) if spec is None: raise ImportError(f"Can't find {module}") if not spec.has_location and hasattr(spec, 'submodule_search_locations'): spec = importlib.util.spec_from_loader('__init__.py', spec.loader) kind = -1 file = None static = isinstance(spec.loader, type) if ( spec.origin == 'frozen' or static and issubclass(spec.loader, importlib.machinery.FrozenImporter) ): kind = PY_FROZEN path = None # imp compabilty suffix = mode = '' # imp compatibility elif ( spec.origin == 'built-in' or static and issubclass(spec.loader, importlib.machinery.BuiltinImporter) ): kind = C_BUILTIN path = None # imp compabilty suffix = mode = '' # imp compatibility elif spec.has_location: path = spec.origin suffix = os.path.splitext(path)[1] mode = 'r' if suffix in importlib.machinery.SOURCE_SUFFIXES else 'rb' if suffix in importlib.machinery.SOURCE_SUFFIXES: kind = PY_SOURCE file = tokenize.open(path) elif suffix in importlib.machinery.BYTECODE_SUFFIXES: kind = PY_COMPILED file = open(path, 'rb') elif suffix in importlib.machinery.EXTENSION_SUFFIXES: kind = C_EXTENSION else: path = None suffix = mode = '' return file, path, (suffix, mode, kind) def get_frozen_object(module, paths=None): spec = find_spec(module, paths) if not spec: raise ImportError(f"Can't find {module}") return spec.loader.get_code(module) def get_module(module, paths, info): spec = find_spec(module, paths) if not spec: raise ImportError(f"Can't find {module}") return module_from_spec(spec)	2.38 KB	2026-01-20 12:58
📄 _importlib.py import sys if sys.version_info < (3, 10): import importlib_metadata as metadata # pragma: no cover else: import importlib.metadata as metadata # noqa: F401 import importlib.resources as resources # noqa: F401	223 B	2026-01-20 12:58
📄 _itertools.py from more_itertools import consume # noqa: F401 # copied from jaraco.itertools 6.1 def ensure_unique(iterable, key=lambda x: x): """ Wrap an iterable to raise a ValueError if non-unique values are encountered. >>> list(ensure_unique('abc')) ['a', 'b', 'c'] >>> consume(ensure_unique('abca')) Traceback (most recent call last): ... ValueError: Duplicate element 'a' encountered. """ seen = set() seen_add = seen.add for element in iterable: k = key(element) if k in seen: raise ValueError(f"Duplicate element {element!r} encountered.") seen_add(k) yield element	657 B	2026-01-20 12:58
📄 _normalization.py """ Helpers for normalization as expected in wheel/sdist/module file names and core metadata """ import re from typing import TYPE_CHECKING import packaging # https://packaging.python.org/en/latest/specifications/core-metadata/#name _VALID_NAME = re.compile(r"^([A-Z0-9]\|[A-Z0-9][A-Z0-9._-][A-Z0-9])$", re.I) _UNSAFE_NAME_CHARS = re.compile(r"[^A-Z0-9._-]+", re.I) _NON_ALPHANUMERIC = re.compile(r"[^A-Z0-9]+", re.I) _PEP440_FALLBACK = re.compile(r"^v?(?P<safe>(?:[0-9]+!)?[0-9]+(?:\.[0-9]+))", re.I) def safe_identifier(name: str) -> str: """Make a string safe to be used as Python identifier. >>> safe_identifier("12abc") '_12abc' >>> safe_identifier("__editable__.myns.pkg-78.9.3_local") '__editable___myns_pkg_78_9_3_local' """ safe = re.sub(r'\W\|^(?=\d)', '_', name) assert safe.isidentifier() return safe def safe_name(component: str) -> str: """Escape a component used as a project name according to Core Metadata. >>> safe_name("hello world") 'hello-world' >>> safe_name("hello?world") 'hello-world' >>> safe_name("hello_world") 'hello_world' """ return _UNSAFE_NAME_CHARS.sub("-", component) def safe_version(version: str) -> str: """Convert an arbitrary string into a valid version string. Can still raise an ``InvalidVersion`` exception. To avoid exceptions use ``best_effort_version``. >>> safe_version("1988 12 25") '1988.12.25' >>> safe_version("v0.2.1") '0.2.1' >>> safe_version("v0.2?beta") '0.2b0' >>> safe_version("v0.2 beta") '0.2b0' >>> safe_version("ubuntu lts") Traceback (most recent call last): ... packaging.version.InvalidVersion: Invalid version: 'ubuntu.lts' """ v = version.replace(' ', '.') try: return str(packaging.version.Version(v)) except packaging.version.InvalidVersion: attempt = _UNSAFE_NAME_CHARS.sub("-", v) return str(packaging.version.Version(attempt)) def best_effort_version(version: str) -> str: """Convert an arbitrary string into a version-like string. Fallback when ``safe_version`` is not safe enough. >>> best_effort_version("v0.2 beta") '0.2b0' >>> best_effort_version("ubuntu lts") '0.dev0+sanitized.ubuntu.lts' >>> best_effort_version("0.23ubuntu1") '0.23.dev0+sanitized.ubuntu1' >>> best_effort_version("0.23-") '0.23.dev0+sanitized' >>> best_effort_version("0.-_") '0.dev0+sanitized' >>> best_effort_version("42.+?1") '42.dev0+sanitized.1' """ try: return safe_version(version) except packaging.version.InvalidVersion: v = version.replace(' ', '.') match = _PEP440_FALLBACK.search(v) if match: safe = match["safe"] rest = v[len(safe) :] else: safe = "0" rest = version safe_rest = _NON_ALPHANUMERIC.sub(".", rest).strip(".") local = f"sanitized.{safe_rest}".strip(".") return safe_version(f"{safe}.dev0+{local}") def safe_extra(extra: str) -> str: """Normalize extra name according to PEP 685 >>> safe_extra("_FrIeNdLy-._.-bArD") 'friendly-bard' >>> safe_extra("FrIeNdLy-._.-bArD__._-") 'friendly-bard' """ return _NON_ALPHANUMERIC.sub("-", extra).strip("-").lower() def filename_component(value: str) -> str: """Normalize each component of a filename (e.g. distribution/version part of wheel) Note: ``value`` needs to be already normalized. >>> filename_component("my-pkg") 'my_pkg' """ return value.replace("-", "_").strip("_") def filename_component_broken(value: str) -> str: """ Produce the incorrect filename component for compatibility. See pypa/setuptools#4167 for detailed analysis. TODO: replace this with filename_component after pip 24 is nearly-ubiquitous. >>> filename_component_broken('foo_bar-baz') 'foo-bar-baz' """ return value.replace('_', '-') def safer_name(value: str) -> str: """Like ``safe_name`` but can be used as filename component for wheel""" # See bdist_wheel.safer_name return ( # Per https://packaging.python.org/en/latest/specifications/name-normalization/#name-normalization re.sub(r"[-_.]+", "-", safe_name(value)) .lower() # Per https://packaging.python.org/en/latest/specifications/binary-distribution-format/#escaping-and-unicode .replace("-", "_") ) def safer_best_effort_version(value: str) -> str: """Like ``best_effort_version`` but can be used as filename component for wheel""" # See bdist_wheel.safer_verion # TODO: Replace with only safe_version in the future (no need for best effort) return filename_component(best_effort_version(value)) def _missing_canonicalize_license_expression(expression: str) -> str: """ Defer import error to affect only users that actually use it https://github.com/pypa/setuptools/issues/4894 >>> _missing_canonicalize_license_expression("a OR b") Traceback (most recent call last): ... ImportError: ...Cannot import `packaging.licenses`... """ raise ImportError( "Cannot import `packaging.licenses`." """ Setuptools>=77.0.0 requires "packaging>=24.2" to work properly. Please make sure you have a suitable version installed. """ ) try: from packaging.licenses import ( canonicalize_license_expression as _canonicalize_license_expression, ) except ImportError: # pragma: nocover if not TYPE_CHECKING: # XXX: pyright is still upset even with # pyright: ignore[reportAssignmentType] _canonicalize_license_expression = _missing_canonicalize_license_expression	5.61 KB	2026-01-20 12:58
📄 _path.py from __future__ import annotations import contextlib import os import sys from typing import TYPE_CHECKING, TypeVar, Union from more_itertools import unique_everseen if TYPE_CHECKING: from typing_extensions import TypeAlias StrPath: TypeAlias = Union[str, os.PathLike[str]] # Same as _typeshed.StrPath StrPathT = TypeVar("StrPathT", bound=Union[str, os.PathLike[str]]) def ensure_directory(path): """Ensure that the parent directory of `path` exists""" dirname = os.path.dirname(path) os.makedirs(dirname, exist_ok=True) def same_path(p1: StrPath, p2: StrPath) -> bool: """Differs from os.path.samefile because it does not require paths to exist. Purely string based (no comparison between i-nodes). >>> same_path("a/b", "./a/b") True >>> same_path("a/b", "a/./b") True >>> same_path("a/b", "././a/b") True >>> same_path("a/b", "./a/b/c/..") True >>> same_path("a/b", "../a/b/c") False >>> same_path("a", "a/b") False """ return normpath(p1) == normpath(p2) def _cygwin_patch(filename: StrPath): # pragma: nocover """ Contrary to POSIX 2008, on Cygwin, getcwd (3) contains symlink components. Using os.path.abspath() works around this limitation. A fix in os.getcwd() would probably better, in Cygwin even more so, except that this seems to be by design... """ return os.path.abspath(filename) if sys.platform == 'cygwin' else filename def normpath(filename: StrPath) -> str: """Normalize a file/dir name for comparison purposes.""" return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename)))) @contextlib.contextmanager def paths_on_pythonpath(paths): """ Add the indicated paths to the head of the PYTHONPATH environment variable so that subprocesses will also see the packages at these paths. Do this in a context that restores the value on exit. >>> getfixture('monkeypatch').setenv('PYTHONPATH', 'anything') >>> with paths_on_pythonpath(['foo', 'bar']): ... assert 'foo' in os.environ['PYTHONPATH'] ... assert 'anything' in os.environ['PYTHONPATH'] >>> os.environ['PYTHONPATH'] 'anything' >>> getfixture('monkeypatch').delenv('PYTHONPATH') >>> with paths_on_pythonpath(['foo', 'bar']): ... assert 'foo' in os.environ['PYTHONPATH'] >>> os.environ.get('PYTHONPATH') """ nothing = object() orig_pythonpath = os.environ.get('PYTHONPATH', nothing) current_pythonpath = os.environ.get('PYTHONPATH', '') try: prefix = os.pathsep.join(unique_everseen(paths)) to_join = filter(None, [prefix, current_pythonpath]) new_path = os.pathsep.join(to_join) if new_path: os.environ['PYTHONPATH'] = new_path yield finally: if orig_pythonpath is nothing: os.environ.pop('PYTHONPATH', None) else: os.environ['PYTHONPATH'] = orig_pythonpath	2.91 KB	2026-01-20 12:58
📄 _reqs.py from __future__ import annotations from collections.abc import Iterable, Iterator from functools import lru_cache from typing import TYPE_CHECKING, Callable, TypeVar, Union, overload import jaraco.text as text from packaging.requirements import Requirement if TYPE_CHECKING: from typing_extensions import TypeAlias _T = TypeVar("_T") _StrOrIter: TypeAlias = Union[str, Iterable[str]] parse_req: Callable[[str], Requirement] = lru_cache()(Requirement) # Setuptools parses the same requirement many times # (e.g. first for validation than for normalisation), # so it might be worth to cache. def parse_strings(strs: _StrOrIter) -> Iterator[str]: """ Yield requirement strings for each specification in `strs`. `strs` must be a string, or a (possibly-nested) iterable thereof. """ return text.join_continuation(map(text.drop_comment, text.yield_lines(strs))) # These overloads are only needed because of a mypy false-positive, pyright gets it right # https://github.com/python/mypy/issues/3737 @overload def parse(strs: _StrOrIter) -> Iterator[Requirement]: ... @overload def parse(strs: _StrOrIter, parser: Callable[[str], _T]) -> Iterator[_T]: ... def parse(strs: _StrOrIter, parser: Callable[[str], _T] = parse_req) -> Iterator[_T]: # type: ignore[assignment] """ Parse requirements. """ return map(parser, parse_strings(strs))	1.35 KB	2026-01-20 12:58
📄 _scripts.py from __future__ import annotations import os import re import shlex import shutil import struct import subprocess import sys import textwrap from collections.abc import Iterable from typing import TYPE_CHECKING, TypedDict from ._importlib import metadata, resources if TYPE_CHECKING: from typing_extensions import Self from .warnings import SetuptoolsWarning from distutils.command.build_scripts import first_line_re from distutils.util import get_platform class _SplitArgs(TypedDict, total=False): comments: bool posix: bool class CommandSpec(list): """ A command spec for a #! header, specified as a list of arguments akin to those passed to Popen. """ options: list[str] = [] split_args = _SplitArgs() @classmethod def best(cls): """ Choose the best CommandSpec class based on environmental conditions. """ return cls @classmethod def _sys_executable(cls): _default = os.path.normpath(sys.executable) return os.environ.get('__PYVENV_LAUNCHER__', _default) @classmethod def from_param(cls, param: Self \| str \| Iterable[str] \| None) -> Self: """ Construct a CommandSpec from a parameter to build_scripts, which may be None. """ if isinstance(param, cls): return param if isinstance(param, str): return cls.from_string(param) if isinstance(param, Iterable): return cls(param) if param is None: return cls.from_environment() raise TypeError(f"Argument has an unsupported type {type(param)}") @classmethod def from_environment(cls): return cls([cls._sys_executable()]) @classmethod def from_string(cls, string: str) -> Self: """ Construct a command spec from a simple string representing a command line parseable by shlex.split. """ items = shlex.split(string, *cls.split_args) return cls(items) def install_options(self, script_text: str): self.options = shlex.split(self._extract_options(script_text)) cmdline = subprocess.list2cmdline(self) if not isascii(cmdline): self.options[:0] = ['-x'] @staticmethod def _extract_options(orig_script): """ Extract any options from the first line of the script. """ first = (orig_script + '\n').splitlines()[0] match = _first_line_re().match(first) options = match.group(1) or '' if match else '' return options.strip() def as_header(self): return self._render(self + list(self.options)) @staticmethod def _strip_quotes(item): _QUOTES = '"\'' for q in _QUOTES: if item.startswith(q) and item.endswith(q): return item[1:-1] return item @staticmethod def _render(items): cmdline = subprocess.list2cmdline( CommandSpec._strip_quotes(item.strip()) for item in items ) return '#!' + cmdline + '\n' class WindowsCommandSpec(CommandSpec): split_args = _SplitArgs(posix=False) class ScriptWriter: """ Encapsulates behavior around writing entry point scripts for console and gui apps. """ template = textwrap.dedent( r""" # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r import re import sys # for compatibility with easy_install; see #2198 __requires__ = %(spec)r try: from importlib.metadata import distribution except ImportError: try: from importlib_metadata import distribution except ImportError: from pkg_resources import load_entry_point def importlib_load_entry_point(spec, group, name): dist_name, _, _ = spec.partition('==') matches = ( entry_point for entry_point in distribution(dist_name).entry_points if entry_point.group == group and entry_point.name == name ) return next(matches).load() globals().setdefault('load_entry_point', importlib_load_entry_point) if __name__ == '__main__': sys.argv[0] = re.sub(r'(-script\.pyw?\|\.exe)?$', '', sys.argv[0]) sys.exit(load_entry_point(%(spec)r, %(group)r, %(name)r)()) """ ).lstrip() command_spec_class = CommandSpec @classmethod def get_args(cls, dist, header=None): """ Yield write_script() argument tuples for a distribution's console_scripts and gui_scripts entry points. """ # If distribution is not an importlib.metadata.Distribution, assume # it's a pkg_resources.Distribution and transform it. if not hasattr(dist, 'entry_points'): SetuptoolsWarning.emit("Unsupported distribution encountered.") dist = metadata.Distribution.at(dist.egg_info) if header is None: header = cls.get_header() spec = f'{dist.name}=={dist.version}' for type_ in 'console', 'gui': group = f'{type_}_scripts' for ep in dist.entry_points.select(group=group): name = ep.name cls._ensure_safe_name(ep.name) script_text = cls.template % locals() args = cls._get_script_args(type_, ep.name, header, script_text) yield from args @staticmethod def _ensure_safe_name(name): """ Prevent paths in _scripts entry point names. """ has_path_sep = re.search(r'[\\/]', name) if has_path_sep: raise ValueError("Path separators not allowed in script names") @classmethod def best(cls): """ Select the best ScriptWriter for this environment. """ if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'): return WindowsScriptWriter.best() else: return cls @classmethod def _get_script_args(cls, type_, name, header, script_text): # Simply write the stub with no extension. yield (name, header + script_text) @classmethod def get_header( cls, script_text: str = "", executable: str \| CommandSpec \| Iterable[str] \| None = None, ) -> str: """Create a #! line, getting options (if any) from script_text""" cmd = cls.command_spec_class.best().from_param(executable) cmd.install_options(script_text) return cmd.as_header() class WindowsScriptWriter(ScriptWriter): command_spec_class = WindowsCommandSpec @classmethod def best(cls): """ Select the best ScriptWriter suitable for Windows """ writer_lookup = dict( executable=WindowsExecutableLauncherWriter, natural=cls, ) # for compatibility, use the executable launcher by default launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable') return writer_lookup[launcher] @classmethod def _get_script_args(cls, type_, name, header, script_text): "For Windows, add a .py extension" ext = dict(console='.pya', gui='.pyw')[type_] if ext not in os.environ['PATHEXT'].lower().split(';'): msg = ( "{ext} not listed in PATHEXT; scripts will not be " "recognized as executables." ).format(**locals()) SetuptoolsWarning.emit(msg) old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe'] old.remove(ext) header = cls._adjust_header(type_, header) blockers = [name + x for x in old] yield name + ext, header + script_text, 't', blockers @classmethod def _adjust_header(cls, type_, orig_header): """ Make sure 'pythonw' is used for gui and 'python' is used for console (regardless of what sys.executable is). """ pattern = 'pythonw.exe' repl = 'python.exe' if type_ == 'gui': pattern, repl = repl, pattern pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE) new_header = pattern_ob.sub(string=orig_header, repl=repl) return new_header if cls._use_header(new_header) else orig_header @staticmethod def _use_header(new_header): """ Should _adjust_header use the replaced header? On non-windows systems, always use. On Windows systems, only use the replaced header if it resolves to an executable on the system. """ clean_header = new_header[2:-1].strip('"') return sys.platform != 'win32' or shutil.which(clean_header) class WindowsExecutableLauncherWriter(WindowsScriptWriter): @classmethod def _get_script_args(cls, type_, name, header, script_text): """ For Windows, add a .py extension and an .exe launcher """ if type_ == 'gui': launcher_type = 'gui' ext = '-script.pyw' old = ['.pyw'] else: launcher_type = 'cli' ext = '-script.py' old = ['.py', '.pyc', '.pyo'] hdr = cls._adjust_header(type_, header) blockers = [name + x for x in old] yield (name + ext, hdr + script_text, 't', blockers) yield ( name + '.exe', get_win_launcher(launcher_type), 'b', # write in binary mode ) if not is_64bit(): # install a manifest for the launcher to prevent Windows # from detecting it as an installer (which it will for # launchers like easy_install.exe). Consider only # adding a manifest for launchers detected as installers. # See Distribute #143 for details. m_name = name + '.exe.manifest' yield (m_name, load_launcher_manifest(name), 't') def get_win_launcher(type): """ Load the Windows launcher (executable) suitable for launching a script. `type` should be either 'cli' or 'gui' Returns the executable as a byte string. """ launcher_fn = f'{type}.exe' if is_64bit(): if get_platform() == "win-arm64": launcher_fn = launcher_fn.replace(".", "-arm64.") else: launcher_fn = launcher_fn.replace(".", "-64.") else: launcher_fn = launcher_fn.replace(".", "-32.") return resources.files('setuptools').joinpath(launcher_fn).read_bytes() def load_launcher_manifest(name): res = resources.files(__name__).joinpath('launcher manifest.xml') return res.read_text(encoding='utf-8') % vars() def _first_line_re(): """ Return a regular expression based on first_line_re suitable for matching strings. """ if isinstance(first_line_re.pattern, str): return first_line_re # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern. return re.compile(first_line_re.pattern.decode()) def is_64bit(): return struct.calcsize("P") == 8 def isascii(s): try: s.encode('ascii') except UnicodeError: return False return True	10.98 KB	2026-01-20 12:58
📄 _shutil.py """Convenience layer on top of stdlib's shutil and os""" import os import stat from typing import Callable, TypeVar from .compat import py311 from distutils import log try: from os import chmod # pyright: ignore[reportAssignmentType] # Losing type-safety w/ pyright, but that's ok except ImportError: # pragma: no cover # Jython compatibility def chmod(args: object, kwargs: object) -> None: # type: ignore[misc] # Mypy reuses the imported definition anyway pass _T = TypeVar("_T") def attempt_chmod_verbose(path, mode): log.debug("changing mode of %s to %o", path, mode) try: chmod(path, mode) except OSError as e: # pragma: no cover log.debug("chmod failed: %s", e) # Must match shutil._OnExcCallback def _auto_chmod( func: Callable[..., _T], arg: str, exc: BaseException ) -> _T: # pragma: no cover """shutils onexc callback to automatically call chmod for certain functions.""" # Only retry for scenarios known to have an issue if func in [os.unlink, os.remove] and os.name == 'nt': attempt_chmod_verbose(arg, stat.S_IWRITE) return func(arg) raise exc def rmtree(path, ignore_errors=False, onexc=_auto_chmod): """ Similar to ``shutil.rmtree`` but automatically executes ``chmod`` for well know Windows failure scenarios. """ return py311.shutil_rmtree(path, ignore_errors, onexc) def rmdir(path, opts): if os.path.isdir(path): rmtree(path, *opts) def current_umask(): tmp = os.umask(0o022) os.umask(tmp) return tmp	1.54 KB	2026-01-20 12:58
📄 _static.py from functools import wraps from typing import TypeVar import packaging.specifiers from .warnings import SetuptoolsDeprecationWarning class Static: """ Wrapper for built-in object types that are allow setuptools to identify static core metadata (in opposition to ``Dynamic``, as defined :pep:`643`). The trick is to mark values with :class:`Static` when they come from ``pyproject.toml`` or ``setup.cfg``, so if any plugin overwrite the value with a built-in, setuptools will be able to recognise the change. We inherit from built-in classes, so that we don't need to change the existing code base to deal with the new types. We also should strive for immutability objects to avoid changes after the initial parsing. """ _mutated_: bool = False # TODO: Remove after deprecation warning is solved def _prevent_modification(target: type, method: str, copying: str) -> None: """ Because setuptools is very flexible we cannot fully prevent plugins and user customizations from modifying static values that were parsed from config files. But we can attempt to block "in-place" mutations and identify when they were done. """ fn = getattr(target, method, None) if fn is None: return @wraps(fn) def _replacement(self: Static, args, kwargs): # TODO: After deprecation period raise NotImplementedError instead of warning # which obviated the existence and checks of the `_mutated_` attribute. self._mutated_ = True SetuptoolsDeprecationWarning.emit( "Direct modification of value will be disallowed", f""" In an effort to implement PEP 643, direct/in-place changes of static values that come from configuration files are deprecated. If you need to modify this value, please first create a copy with {copying} and make sure conform to all relevant standards when overriding setuptools functionality (https://packaging.python.org/en/latest/specifications/). """, due_date=(2025, 10, 10), # Initially introduced in 2024-09-06 ) return fn(self, args, **kwargs) _replacement.__doc__ = "" # otherwise doctest may fail. setattr(target, method, _replacement) class Str(str, Static): pass class Tuple(tuple, Static): pass class List(list, Static): """ :meta private: >>> x = List([1, 2, 3]) >>> is_static(x) True >>> x += [0] # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): SetuptoolsDeprecationWarning: Direct modification ... >>> is_static(x) # no longer static after modification False >>> y = list(x) >>> y.clear() >>> y [] >>> y == x False >>> is_static(List(y)) True """ # Make `List` immutable-ish # (certain places of setuptools/distutils issue a warn if we use tuple instead of list) for _method in ( '__delitem__', '__iadd__', '__setitem__', 'append', 'clear', 'extend', 'insert', 'remove', 'reverse', 'pop', ): _prevent_modification(List, _method, "`list(value)`") class Dict(dict, Static): """ :meta private: >>> x = Dict({'a': 1, 'b': 2}) >>> is_static(x) True >>> x['c'] = 0 # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): SetuptoolsDeprecationWarning: Direct modification ... >>> x._mutated_ True >>> is_static(x) # no longer static after modification False >>> y = dict(x) >>> y.popitem() ('b', 2) >>> y == x False >>> is_static(Dict(y)) True """ # Make `Dict` immutable-ish (we cannot inherit from types.MappingProxyType): for _method in ( '__delitem__', '__ior__', '__setitem__', 'clear', 'pop', 'popitem', 'setdefault', 'update', ): _prevent_modification(Dict, _method, "`dict(value)`") class SpecifierSet(packaging.specifiers.SpecifierSet, Static): """Not exactly a built-in type but useful for ``requires-python``""" T = TypeVar("T") def noop(value: T) -> T: """ >>> noop(42) 42 """ return value _CONVERSIONS = {str: Str, tuple: Tuple, list: List, dict: Dict} def attempt_conversion(value: T) -> T: """ >>> is_static(attempt_conversion("hello")) True >>> is_static(object()) False """ return _CONVERSIONS.get(type(value), noop)(value) # type: ignore[call-overload] def is_static(value: object) -> bool: """ >>> is_static(a := Dict({'a': 1})) True >>> is_static(dict(a)) False >>> is_static(b := List([1, 2, 3])) True >>> is_static(list(b)) False """ return isinstance(value, Static) and not value._mutated_ EMPTY_LIST = List() EMPTY_DICT = Dict()	4.74 KB	2026-01-20 12:58
📁 _vendor	-	2026-03-21 15:45
📄 archive_util.py """Utilities for extracting common archive formats""" import contextlib import os import posixpath import shutil import tarfile import zipfile from ._path import ensure_directory from distutils.errors import DistutilsError __all__ = [ "unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter", "UnrecognizedFormat", "extraction_drivers", "unpack_directory", ] class UnrecognizedFormat(DistutilsError): """Couldn't recognize the archive type""" def default_filter(src, dst): """The default progress/filter callback; returns True for all files""" return dst def unpack_archive( filename, extract_dir, progress_filter=default_filter, drivers=None ) -> None: """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat`` `progress_filter` is a function taking two arguments: a source path internal to the archive ('/'-separated), and a filesystem path where it will be extracted. The callback must return the desired extract path (which may be the same as the one passed in), or else ``None`` to skip that file or directory. The callback can thus be used to report on the progress of the extraction, as well as to filter the items extracted or alter their extraction paths. `drivers`, if supplied, must be a non-empty sequence of functions with the same signature as this function (minus the `drivers` argument), that raise ``UnrecognizedFormat`` if they do not support extracting the designated archive type. The `drivers` are tried in sequence until one is found that does not raise an error, or until all are exhausted (in which case ``UnrecognizedFormat`` is raised). If you do not supply a sequence of drivers, the module's ``extraction_drivers`` constant will be used, which means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that order. """ for driver in drivers or extraction_drivers: try: driver(filename, extract_dir, progress_filter) except UnrecognizedFormat: continue else: return else: raise UnrecognizedFormat(f"Not a recognized archive type: {filename}") def unpack_directory(filename, extract_dir, progress_filter=default_filter) -> None: """ "Unpack" a directory, using the same interface as for archives Raises ``UnrecognizedFormat`` if `filename` is not a directory """ if not os.path.isdir(filename): raise UnrecognizedFormat(f"{filename} is not a directory") paths = { filename: ('', extract_dir), } for base, dirs, files in os.walk(filename): src, dst = paths[base] for d in dirs: paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d) for f in files: target = os.path.join(dst, f) target = progress_filter(src + f, target) if not target: # skip non-files continue ensure_directory(target) f = os.path.join(base, f) shutil.copyfile(f, target) shutil.copystat(f, target) def unpack_zipfile(filename, extract_dir, progress_filter=default_filter) -> None: """Unpack zip `filename` to `extract_dir` Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined by ``zipfile.is_zipfile()``). See ``unpack_archive()`` for an explanation of the `progress_filter` argument. """ if not zipfile.is_zipfile(filename): raise UnrecognizedFormat(f"{filename} is not a zip file") with zipfile.ZipFile(filename) as z: _unpack_zipfile_obj(z, extract_dir, progress_filter) def _unpack_zipfile_obj(zipfile_obj, extract_dir, progress_filter=default_filter): """Internal/private API used by other parts of setuptools. Similar to ``unpack_zipfile``, but receives an already opened :obj:`zipfile.ZipFile` object instead of a filename. """ for info in zipfile_obj.infolist(): name = info.filename # don't extract absolute paths or ones with .. in them if name.startswith('/') or '..' in name.split('/'): continue target = os.path.join(extract_dir, name.split('/')) target = progress_filter(name, target) if not target: continue if name.endswith('/'): # directory ensure_directory(target) else: # file ensure_directory(target) data = zipfile_obj.read(info.filename) with open(target, 'wb') as f: f.write(data) unix_attributes = info.external_attr >> 16 if unix_attributes: os.chmod(target, unix_attributes) def _resolve_tar_file_or_dir(tar_obj, tar_member_obj): """Resolve any links and extract link targets as normal files.""" while tar_member_obj is not None and ( tar_member_obj.islnk() or tar_member_obj.issym() ): linkpath = tar_member_obj.linkname if tar_member_obj.issym(): base = posixpath.dirname(tar_member_obj.name) linkpath = posixpath.join(base, linkpath) linkpath = posixpath.normpath(linkpath) tar_member_obj = tar_obj._getmember(linkpath) is_file_or_dir = tar_member_obj is not None and ( tar_member_obj.isfile() or tar_member_obj.isdir() ) if is_file_or_dir: return tar_member_obj raise LookupError('Got unknown file type') def _iter_open_tar(tar_obj, extract_dir, progress_filter): """Emit member-destination pairs from a tar archive.""" # don't do any chowning! tar_obj.chown = lambda args: None with contextlib.closing(tar_obj): for member in tar_obj: name = member.name # don't extract absolute paths or ones with .. in them if name.startswith('/') or '..' in name.split('/'): continue prelim_dst = os.path.join(extract_dir, *name.split('/')) try: member = _resolve_tar_file_or_dir(tar_obj, member) except LookupError: continue final_dst = progress_filter(name, prelim_dst) if not final_dst: continue if final_dst.endswith(os.sep): final_dst = final_dst[:-1] yield member, final_dst def unpack_tarfile(filename, extract_dir, progress_filter=default_filter) -> bool: """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir` Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined by ``tarfile.open()``). See ``unpack_archive()`` for an explanation of the `progress_filter` argument. """ try: tarobj = tarfile.open(filename) except tarfile.TarError as e: raise UnrecognizedFormat( f"{filename} is not a compressed or uncompressed tar file" ) from e for member, final_dst in _iter_open_tar( tarobj, extract_dir, progress_filter, ): try: # XXX Ugh tarobj._extract_member(member, final_dst) except tarfile.ExtractError: # chown/chmod/mkfifo/mknode/makedev failed pass return True extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile	7.18 KB	2026-01-20 12:58
📄 build_meta.py """A PEP 517 interface to setuptools Previously, when a user or a command line tool (let's call it a "frontend") needed to make a request of setuptools to take a certain action, for example, generating a list of installation requirements, the frontend would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line. PEP 517 defines a different method of interfacing with setuptools. Rather than calling "setup.py" directly, the frontend should: 1. Set the current directory to the directory with a setup.py file 2. Import this module into a safe python interpreter (one in which setuptools can potentially set global variables or crash hard). 3. Call one of the functions defined in PEP 517. What each function does is defined in PEP 517. However, here is a "casual" definition of the functions (this definition should not be relied on for bug reports or API stability): - `build_wheel`: build a wheel in the folder and return the basename - `get_requires_for_build_wheel`: get the `setup_requires` to build - `prepare_metadata_for_build_wheel`: get the `install_requires` - `build_sdist`: build an sdist in the folder and return the basename - `get_requires_for_build_sdist`: get the `setup_requires` to build Again, this is not a formal definition! Just a "taste" of the module. """ from __future__ import annotations import contextlib import io import os import shlex import shutil import sys import tempfile import tokenize import warnings from collections.abc import Iterable, Iterator, Mapping from pathlib import Path from typing import TYPE_CHECKING, Union import setuptools from . import errors from ._path import StrPath, same_path from ._reqs import parse_strings from .warnings import SetuptoolsDeprecationWarning import distutils from distutils.util import strtobool if TYPE_CHECKING: from typing_extensions import TypeAlias __all__ = [ 'get_requires_for_build_sdist', 'get_requires_for_build_wheel', 'prepare_metadata_for_build_wheel', 'build_wheel', 'build_sdist', 'get_requires_for_build_editable', 'prepare_metadata_for_build_editable', 'build_editable', '__legacy__', 'SetupRequirementsError', ] class SetupRequirementsError(BaseException): def __init__(self, specifiers) -> None: self.specifiers = specifiers class Distribution(setuptools.dist.Distribution): def fetch_build_eggs(self, specifiers): specifier_list = list(parse_strings(specifiers)) raise SetupRequirementsError(specifier_list) @classmethod @contextlib.contextmanager def patch(cls): """ Replace distutils.dist.Distribution with this class for the duration of this context. """ orig = distutils.core.Distribution distutils.core.Distribution = cls # type: ignore[misc] # monkeypatching try: yield finally: distutils.core.Distribution = orig # type: ignore[misc] # monkeypatching @contextlib.contextmanager def no_install_setup_requires(): """Temporarily disable installing setup_requires Under PEP 517, the backend reports build dependencies to the frontend, and the frontend is responsible for ensuring they're installed. So setuptools (acting as a backend) should not try to install them. """ orig = setuptools._install_setup_requires setuptools._install_setup_requires = lambda attrs: None try: yield finally: setuptools._install_setup_requires = orig def _get_immediate_subdirectories(a_dir): return [ name for name in os.listdir(a_dir) if os.path.isdir(os.path.join(a_dir, name)) ] def _file_with_extension(directory: StrPath, extension: str \| tuple[str, ...]): matching = (f for f in os.listdir(directory) if f.endswith(extension)) try: (file,) = matching except ValueError: raise ValueError( 'No distribution was found. Ensure that `setup.py` ' 'is not empty and that it calls `setup()`.' ) from None return file def _open_setup_script(setup_script): if not os.path.exists(setup_script): # Supply a default setup.py return io.StringIO("from setuptools import setup; setup()") return tokenize.open(setup_script) @contextlib.contextmanager def suppress_known_deprecation(): with warnings.catch_warnings(): warnings.filterwarnings('ignore', 'setup.py install is deprecated') yield _ConfigSettings: TypeAlias = Union[Mapping[str, Union[str, list[str], None]], None] """ Currently the user can run:: pip install -e . --config-settings key=value python -m build -C--key=value -C key=value - pip will pass both key and value as strings and overwriting repeated keys (pypa/pip#11059). - build will accumulate values associated with repeated keys in a list. It will also accept keys with no associated value. This means that an option passed by build can be ``str \| list[str] \| None``. - PEP 517 specifies that ``config_settings`` is an optional dict. """ class _ConfigSettingsTranslator: """Translate ``config_settings`` into distutils-style command arguments. Only a limited number of options is currently supported. """ # See pypa/setuptools#1928 pypa/setuptools#2491 def _get_config(self, key: str, config_settings: _ConfigSettings) -> list[str]: """ Get the value of a specific key in ``config_settings`` as a list of strings. >>> fn = _ConfigSettingsTranslator()._get_config >>> fn("--global-option", None) [] >>> fn("--global-option", {}) [] >>> fn("--global-option", {'--global-option': 'foo'}) ['foo'] >>> fn("--global-option", {'--global-option': ['foo']}) ['foo'] >>> fn("--global-option", {'--global-option': 'foo'}) ['foo'] >>> fn("--global-option", {'--global-option': 'foo bar'}) ['foo', 'bar'] """ cfg = config_settings or {} opts = cfg.get(key) or [] return shlex.split(opts) if isinstance(opts, str) else opts def _global_args(self, config_settings: _ConfigSettings) -> Iterator[str]: """ Let the user specify ``verbose`` or ``quiet`` + escape hatch via ``--global-option``. Note: ``-v``, ``-vv``, ``-vvv`` have similar effects in setuptools, so we just have to cover the basic scenario ``-v``. >>> fn = _ConfigSettingsTranslator()._global_args >>> list(fn(None)) [] >>> list(fn({"verbose": "False"})) ['-q'] >>> list(fn({"verbose": "1"})) ['-v'] >>> list(fn({"--verbose": None})) ['-v'] >>> list(fn({"verbose": "true", "--global-option": "-q --no-user-cfg"})) ['-v', '-q', '--no-user-cfg'] >>> list(fn({"--quiet": None})) ['-q'] """ cfg = config_settings or {} falsey = {"false", "no", "0", "off"} if "verbose" in cfg or "--verbose" in cfg: level = str(cfg.get("verbose") or cfg.get("--verbose") or "1") yield ("-q" if level.lower() in falsey else "-v") if "quiet" in cfg or "--quiet" in cfg: level = str(cfg.get("quiet") or cfg.get("--quiet") or "1") yield ("-v" if level.lower() in falsey else "-q") yield from self._get_config("--global-option", config_settings) def __dist_info_args(self, config_settings: _ConfigSettings) -> Iterator[str]: """ The ``dist_info`` command accepts ``tag-date`` and ``tag-build``. .. warning:: We cannot use this yet as it requires the ``sdist`` and ``bdist_wheel`` commands run in ``build_sdist`` and ``build_wheel`` to reuse the egg-info directory created in ``prepare_metadata_for_build_wheel``. >>> fn = _ConfigSettingsTranslator()._ConfigSettingsTranslator__dist_info_args >>> list(fn(None)) [] >>> list(fn({"tag-date": "False"})) ['--no-date'] >>> list(fn({"tag-date": None})) ['--no-date'] >>> list(fn({"tag-date": "true", "tag-build": ".a"})) ['--tag-date', '--tag-build', '.a'] """ cfg = config_settings or {} if "tag-date" in cfg: val = strtobool(str(cfg["tag-date"] or "false")) yield ("--tag-date" if val else "--no-date") if "tag-build" in cfg: yield from ["--tag-build", str(cfg["tag-build"])] def _editable_args(self, config_settings: _ConfigSettings) -> Iterator[str]: """ The ``editable_wheel`` command accepts ``editable-mode=strict``. >>> fn = _ConfigSettingsTranslator()._editable_args >>> list(fn(None)) [] >>> list(fn({"editable-mode": "strict"})) ['--mode', 'strict'] """ cfg = config_settings or {} mode = cfg.get("editable-mode") or cfg.get("editable_mode") if not mode: return yield from ["--mode", str(mode)] def _arbitrary_args(self, config_settings: _ConfigSettings) -> Iterator[str]: """ Users may expect to pass arbitrary lists of arguments to a command via "--global-option" (example provided in PEP 517 of a "escape hatch"). >>> fn = _ConfigSettingsTranslator()._arbitrary_args >>> list(fn(None)) [] >>> list(fn({})) [] >>> list(fn({'--build-option': 'foo'})) ['foo'] >>> list(fn({'--build-option': ['foo']})) ['foo'] >>> list(fn({'--build-option': 'foo'})) ['foo'] >>> list(fn({'--build-option': 'foo bar'})) ['foo', 'bar'] >>> list(fn({'--global-option': 'foo'})) [] """ yield from self._get_config("--build-option", config_settings) class _BuildMetaBackend(_ConfigSettingsTranslator): def _get_build_requires( self, config_settings: _ConfigSettings, requirements: list[str] ): sys.argv = [ sys.argv[:1], self._global_args(config_settings), "egg_info", ] try: with Distribution.patch(): self.run_setup() except SetupRequirementsError as e: requirements += e.specifiers return requirements def run_setup(self, setup_script: str = 'setup.py'): # Note that we can reuse our build directory between calls # Correctness comes first, then optimization later __file__ = os.path.abspath(setup_script) __name__ = '__main__' with _open_setup_script(__file__) as f: code = f.read().replace(r'\r\n', r'\n') try: exec(code, locals()) except SystemExit as e: if e.code: raise # We ignore exit code indicating success SetuptoolsDeprecationWarning.emit( "Running `setup.py` directly as CLI tool is deprecated.", "Please avoid using `sys.exit(0)` or similar statements " "that don't fit in the paradigm of a configuration file.", see_url="https://blog.ganssle.io/articles/2021/10/" "setup-py-deprecated.html", ) def get_requires_for_build_wheel(self, config_settings: _ConfigSettings = None): return self._get_build_requires(config_settings, requirements=[]) def get_requires_for_build_sdist(self, config_settings: _ConfigSettings = None): return self._get_build_requires(config_settings, requirements=[]) def _bubble_up_info_directory( self, metadata_directory: StrPath, suffix: str ) -> str: """ PEP 517 requires that the .dist-info directory be placed in the metadata_directory. To comply, we MUST copy the directory to the root. Returns the basename of the info directory, e.g. `proj-0.0.0.dist-info`. """ info_dir = self._find_info_directory(metadata_directory, suffix) if not same_path(info_dir.parent, metadata_directory): shutil.move(str(info_dir), metadata_directory) # PEP 517 allow other files and dirs to exist in metadata_directory return info_dir.name def _find_info_directory(self, metadata_directory: StrPath, suffix: str) -> Path: for parent, dirs, _ in os.walk(metadata_directory): candidates = [f for f in dirs if f.endswith(suffix)] if len(candidates) != 0 or len(dirs) != 1: assert len(candidates) == 1, f"Multiple {suffix} directories found" return Path(parent, candidates[0]) msg = f"No {suffix} directory found in {metadata_directory}" raise errors.InternalError(msg) def prepare_metadata_for_build_wheel( self, metadata_directory: StrPath, config_settings: _ConfigSettings = None ): sys.argv = [ sys.argv[:1], self._global_args(config_settings), "dist_info", "--output-dir", str(metadata_directory), "--keep-egg-info", ] with no_install_setup_requires(): self.run_setup() self._bubble_up_info_directory(metadata_directory, ".egg-info") return self._bubble_up_info_directory(metadata_directory, ".dist-info") def _build_with_temp_dir( self, setup_command: Iterable[str], result_extension: str \| tuple[str, ...], result_directory: StrPath, config_settings: _ConfigSettings, arbitrary_args: Iterable[str] = (), ): result_directory = os.path.abspath(result_directory) # Build in a temporary directory, then copy to the target. os.makedirs(result_directory, exist_ok=True) with tempfile.TemporaryDirectory( prefix=".tmp-", dir=result_directory ) as tmp_dist_dir: sys.argv = [ sys.argv[:1], self._global_args(config_settings), setup_command, "--dist-dir", tmp_dist_dir, arbitrary_args, ] with no_install_setup_requires(): self.run_setup() result_basename = _file_with_extension(tmp_dist_dir, result_extension) result_path = os.path.join(result_directory, result_basename) if os.path.exists(result_path): # os.rename will fail overwriting on non-Unix. os.remove(result_path) os.rename(os.path.join(tmp_dist_dir, result_basename), result_path) return result_basename def build_wheel( self, wheel_directory: StrPath, config_settings: _ConfigSettings = None, metadata_directory: StrPath \| None = None, ): def _build(cmd: list[str]): with suppress_known_deprecation(): return self._build_with_temp_dir( cmd, '.whl', wheel_directory, config_settings, self._arbitrary_args(config_settings), ) if metadata_directory is None: return _build(['bdist_wheel']) try: return _build(['bdist_wheel', '--dist-info-dir', str(metadata_directory)]) except SystemExit as ex: # pragma: nocover # pypa/setuptools#4683 if "--dist-info-dir not recognized" not in str(ex): raise _IncompatibleBdistWheel.emit() return _build(['bdist_wheel']) def build_sdist( self, sdist_directory: StrPath, config_settings: _ConfigSettings = None ): return self._build_with_temp_dir( ['sdist', '--formats', 'gztar'], '.tar.gz', sdist_directory, config_settings ) def _get_dist_info_dir(self, metadata_directory: StrPath \| None) -> str \| None: if not metadata_directory: return None dist_info_candidates = list(Path(metadata_directory).glob(".dist-info")) assert len(dist_info_candidates) <= 1 return str(dist_info_candidates[0]) if dist_info_candidates else None def build_editable( self, wheel_directory: StrPath, config_settings: _ConfigSettings = None, metadata_directory: StrPath \| None = None, ): # XXX can or should we hide our editable_wheel command normally? info_dir = self._get_dist_info_dir(metadata_directory) opts = ["--dist-info-dir", info_dir] if info_dir else [] cmd = ["editable_wheel", opts, *self._editable_args(config_settings)] with suppress_known_deprecation(): return self._build_with_temp_dir( cmd, ".whl", wheel_directory, config_settings ) def get_requires_for_build_editable(self, config_settings: _ConfigSettings = None): return self.get_requires_for_build_wheel(config_settings) def prepare_metadata_for_build_editable( self, metadata_directory: StrPath, config_settings: _ConfigSettings = None ): return self.prepare_metadata_for_build_wheel( metadata_directory, config_settings ) class _BuildMetaLegacyBackend(_BuildMetaBackend): """Compatibility backend for setuptools This is a version of setuptools.build_meta that endeavors to maintain backwards compatibility with pre-PEP 517 modes of invocation. It exists as a temporary bridge between the old packaging mechanism and the new packaging mechanism, and will eventually be removed. """ def run_setup(self, setup_script: str = 'setup.py'): # In order to maintain compatibility with scripts assuming that # the setup.py script is in a directory on the PYTHONPATH, inject # '' into sys.path. (pypa/setuptools#1642) sys_path = list(sys.path) # Save the original path script_dir = os.path.dirname(os.path.abspath(setup_script)) if script_dir not in sys.path: sys.path.insert(0, script_dir) # Some setup.py scripts (e.g. in pygame and numpy) use sys.argv[0] to # get the directory of the source code. They expect it to refer to the # setup.py script. sys_argv_0 = sys.argv[0] sys.argv[0] = setup_script try: super().run_setup(setup_script=setup_script) finally: # While PEP 517 frontends should be calling each hook in a fresh # subprocess according to the standard (and thus it should not be # strictly necessary to restore the old sys.path), we'll restore # the original path so that the path manipulation does not persist # within the hook after run_setup is called. sys.path[:] = sys_path sys.argv[0] = sys_argv_0 class _IncompatibleBdistWheel(SetuptoolsDeprecationWarning): _SUMMARY = "wheel.bdist_wheel is deprecated, please import it from setuptools" _DETAILS = """ Ensure that any custom bdist_wheel implementation is a subclass of setuptools.command.bdist_wheel.bdist_wheel. """ _DUE_DATE = (2025, 10, 15) # Initially introduced in 2024/10/15, but maybe too disruptive to be enforced? _SEE_URL = "https://github.com/pypa/wheel/pull/631" # The primary backend _BACKEND = _BuildMetaBackend() 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 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 # The legacy backend __legacy__ = _BuildMetaLegacyBackend()	19.5 KB	2026-01-20 12:58
📄 cli-32.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��z 2�da�da�da�c�a�dasee`�dase�a�dasea`�dase``�daseg`�da�ce`�da�ea�da�d``�da�d�a�da�df`�daRich�da��PE��L��'hd��$��0��@��p��@��6��P��`��2��2��@��0��.text�� `.rdata�� 0��@��@.data��@��(��@��.rsrc��P����@��@.reloc��`��,��@��B��C@��U��}�u�@@��t j�P�0@��]��U��EPj��u�u��p�0��1@��]��U��j��u�u��]��U��S�]VW�K��C��u�+�j�]��P�x0@��ȃ��M�3��"�q3ɉM��~S�U�<\uG�&<"u ��~Wj\V��M��U�3��\F�3��A�F�M�;�\|�~Wj\V�t��E�_f�"�^[��]��U��@@�3ŉE��E��E��h��Pj��0@�j�h��jj�jh��P��0@�j�h��QP�0@��Q�A��u�+ʍ��;�v�8.t��H;�w퍍��If��A�I��u��1@��1@��Af��1@�f�A��1@�W�A ��j�P��u2��Ph�1@�j��0@��P��G_�M�3��]�Vh��PW��W��H@;�s��t �� t�� u�j��h�1@�P�1@��t&��1@��~�1@��1@�fօ��΍Q�A��u�S+�jQ�x0@��3ۉ��Q��1@��tD��FFP�1@��u�F��P�1@��t��tm��\uC�ƀ�"u0�Ã��u 3��3��9��EȈ��tSj\W��3ۊ��o��G�g��tSj\W��3ۋ��@��G��<�t-�P�1@��t�FFP�1@��u�>��;�Ǌ��t��@��/u�\��u�5h0@��P��P��P��PW�փ��\��P��P��P��P��P�֍��Q�A��u�+ʊ� �� Ӏ�\u�Q�3��\��\tf��;�r ��H�8\u�j�W��P��P��P�l0@��=x0@�jh��׋��h��PV��1@��(�,�x0@�jh��h��WV�1@��=x0@��u/�3h�1@�j��0@��P�r��F[^_�M�3��Q��]Ë��j� ��A�P�׋�V��~��{��9��~��4��R��C��;�\|勵��P�3��9��~/��4��C��;�\|勵��}��t@��V��0@��Vh�1@�j��0@��P�l��[^_�M�3��I��]Ë΍Q�A��u��+ʺ��y;�~0�󐋅��Y@��A��u�+�GB�;�\|ߋ��x0@�jW��Vh�1@�P��N��F��u��+�;�~O@�ff��4��h�1@�P�d��QD��A��u�+�FG�;�\|�W�ǅ��jh@��ǅ��D��f��f��f��f��f��f��f��f��0@��P��Pj�j�j�jj�j��j��0@��u,hP1@�j��0@��P��3�[^_�M�3��]Ë��j��@@��0@��P��0@��u,hl1@�j��0@��P�v��3�[^_�M�3��V��]ËM��3�[^_�?��]��U��EPj��uj��u��p��Q��0@��H�]�; @@�u��y��Vj�v��V��P��D��j�0��^��ts��l��h"@��n��P�>��YY��uQ��c��th�@��Y�)��$��P�G��Y��t� ��T��u�j�-��3��P��Y�jh�5@��/��j��Y��P��2ۈ]�e��Eܡ<C@�3�A;��/��uI� <C@�h<1@�h01@�� YY��t�E��h,1@�h$1@��[ ��YY�<C@��و]�u��Y�i��3�9>tV�9��Y��t�6WjW��1@��G��9>tV��Y��t�6�$ ��Y�� 0� ��WV�0�q��.��tk��u�� j�j�{��YY�E��5�M��E�QP�{ ��YYËe��t2�}��u� ��E��E�M�d� ��Y_^[��j��V�j ��u��h ��t��U��j��D0@��u�H0@�h ��@0@�P�<0@�]�U��$��j�80@��tjY�)� A@�� A@��A@��A@��5A@��=A@�f�8A@�f� ,A@�f�A@�f�A@�f�%�A@�f�-�@@��0A@��E��$A@��E�(A@��E�4A@��p@@��(A@��,@@�� @@� ��$@@��0@@��jXk��ǀ4@@��jXk�� @@��L�jX�� @@��L�h2@��U��EV�H<��A�Q��Ak�(�;�t�M;Jr �BB;�r��(;�u�3�^]Ë��V��t d��@C@��P�;�t3��u�2�^ð^�U��}�u�DC@��v��r��u2�]��e��u j��Z��Y��]�U��=EC@��t�]�V�u��t��ub��t&��u"hHC@��Y��uhTC@��y��Y��t+2��0�� HC@�� LC@�� PC@�� TC@�� XC@�� \C@��EC@��^]�j�/��jh�6@��K��e��MZ��f9��@�u]�<�@��@�PE��uL��f9��@�u>�E��@�+�PQ�\|��YY��t'�x$�\|!�E��E��3Ɂ8��Ëe��E��2��M�d� ��Y_^[��U��t�}�u 3��@C@��]�U��=DC@��t�}�u�u��u��YY�]�U��=HC@��uu�T��hHC@��B��Y��Y��#E]�U��u��Y��H]�U��e��E�e��P�(0@��E�3E�E��,0@�1E��00@�1E��E�P�40@��E�M�3E�3E�3��Ë @@�VW�N�@��;�t��u&��;�u�O�@��u G��ȉ @@��_� �@@�^�3��3�@ø�@��h`C@��$0@�ð�h��h��j��g��u�j�?��hC@��H�$�H��H��H�3�9@@��ø�C@�ø�C@��U��$��Sj�80@��t�M�)j��$��j�P�F��\|��x��f��f��f��t��f��p��f��l��f��h��E��E��ǅ��@�jP��E�j�P��E��E��@�E��E�� 0@�j��X��ۍE��E��ۉE��D0@��E�P�H0@��u��uj��Y[��e��j��L0@��t3�MZ��f9u)�H<ȁ9PE��u��f9Au�ytv��2��h�!@��D0@��U��VW�}�7�>csm�u%�~u�F= �t=!�t="�t=�@�t_3�^]��0�w��0�\��̃%pC@��SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[�SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[��h�"@�d�5��D$�l$�l$+�SVW�@@�1E�3�P�e�u��E��E��E��E�d��U��V�u�6��u��u�uVh2@�h@@��^]�U��%tC@��$� @@�j �80@��e��3�SVW3ɍ}�S��[��w�O3ɉW�E܋}�E�Genu�E�5ineI�E��E�5ntel�E�3�@S��[��]܉�E�E�ǉs�K�SuC�E�%�?�=��t#=`�t=p�t=P�t=`�t=p�u�=xC@��=xC@��=xC@��M�jX�M�9E�\|03�S��[��]܉�s�K�M��S�]��t��=xC@��]�@@��tC@��@@��tC@��@@��ty��tq3�ЉE�U�E�M�j^#�;�uW�@@��tC@��@@�� t;�� tC@��@@��#�;�u�E��M�#�;�u � @@�@�5tC@�_^[3��3�9@@��%T0@��%X0@��%`0@��%\0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%1@��%�0@��%�0@��%�0@��%�0@��%t0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@�U��Q�=tC@�\|f�}��t �}��uT�]��E��?��t?��u��é��t��u��é��u��é ��u��ø��ËE��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��@��@��@@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.py��Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s�� @@�p@@��@@��3@��1@��3@�� 1@��'hd�� l��`3��`��"��3��,��H3��"��(#��#��$��$��$��$��c$��k$��@��"��N%��x��.text$mn��0��.idata$5��1��.00cfg��$1��.CRT$XCA��(1��.CRT$XCAA��,1��.CRT$XCZ��01��.CRT$XIA��41��.CRT$XIAA��81��.CRT$XIAC��<1��.CRT$XIZ��@1��.CRT$XPA��D1��.CRT$XPZ��H1��.CRT$XTA��L1��.CRT$XTZ��P1��.rdata��3��.rdata$sxdata��3��\��.rdata$voltmd��`3��l��.rdata$zzzdbg��5��.rtc$IAA��5��.rtc$IZZ��5��.rtc$TAA��5��.rtc$TZZ��5��<��.xdata$x��6��.idata$2��6��.idata$3��6��.idata$4��8��.idata$6��@��.data��@��x��.bss��P��`��.rsrc$01��`P��.rsrc$02��,@�@@��N@�a@��6��8��0��L7��,9��T0��l7��;��t0��`7��;��h0��7��;��0��7��<��0��8��4<��1��7��V<��0��x7��v<��0��7��<��0��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��CreateFileA�dGetFinalPathNameByHandleA��WaitForSingleObject�QGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��H�memset��__current_exception��__current_exception_context�5�_except_handler4_common�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�B�_seh_filter_exe�D�_set_app_type�.�__setusermatherr��_configure_narrow_argv��5�_initialize_narrow_environment���_get_initial_narrow_environment�8�_initterm�9�_initterm_e�X�exit��%�_exit�T�_set_fmode��_cexit��_c_exit�?�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��6�_initialize_onexit_table��>�_register_onexit_function��_crt_atexit��_controlfp_s��j�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll��UnhandledExceptionFilter��SetUnhandledExceptionFilter�,GetCurrentProcess��TerminateProcess��IsProcessorFeaturePresent�mQueryPerformanceCounter�-GetCurrentProcessId�1GetCurrentThreadId��GetSystemTimeAsFileTime��InitializeSListHead��IsDebuggerPresent��GetModuleHandleW��DN�@��0�� H��`P��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��00'0[0�0J1u1�1�1�1222<2D2�2�2�2�2�2303H3j3)4<4s4M5S5w5�5�5�5�5�5�6�6�6>7I7�7�7(8P8Y8a8�8�8�8�8�8!949x9�9:3:H:M:R:s:x:�:�:�;�;�;�;�;�;�;�;�;�;�;�;�<<<<<#<+<3<;<G<P<U<[<e<o<<�<�<�<=4=g=�=�=�=�=�=�=�=�=�=�=>>> >>�>�>�>�>?'?0?=?S?�?�?�?�?�?�� 000%0�011;1z1�1�1�1�1�1222A2^2�2�2�2�2�2u3~3�3�3�3�3�3�3�3+444=4K4T4v4}4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�455555 5&5,52585>5D5J5T5��0��(��1(1418122L2P2X2�2�2�5�566��	11.5 KB	2026-01-20 12:58
📄 cli-64.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��b�c�1�c�1�c�1�61�c�1�0�c�1X1�c�1�0�c�1�0�c�1�0�c�1��0�c�1�c�1�c�1��0�c�1�Z1�c�1��0�c�1Rich�c�1��PE��d��'hd��"�$��"��@��@��`��:��p��`��0��5��3��@��0��P��.text�� `.rdata��,��0��@��@.data��H��P��0��@��.pdata��`��2��@��@.rsrc��p��4��@��@.reloc��0��6��@��B��H�)F��H��(��u� "@��t3� ��H��(��H�T$L�D$L�L$ SVWH��0H��H�t$`H��E3�H�t$ L��H��H��!��H��0_^[��E3��8��H�\$H�l$H�t$H�\|$ ATAVAWH�� H��L��H��D��H��<�u��, ��3�L��A�?L��3�H��3!��t�KH��"!��u��3H��@��ta@�� !��t��tO@��\u��@��"u�׃�u 3��3��E��tL�ǲ\I��$��L�3�@��t�A�6I��딅�tL�ǲ\I��L�3�A��I��Ic�AA�M�t�@��t,��y ��tD��KH��c ��u�;��8��H�\$@I��H�l$HH�t$PH�\|$XH�� A_A^A\��H�\$H�l$H�t$H�\|$ AVH�� H��H��H�ǀ<9�u��?��Hc�H��3�Hc�L��"H�X��~X�<\u��&<"u ��~��\D��H��H�3��\H��3��H�ƈH��H��u��~��\D��H��H�H�l$8I��H�t$@H�\|$Hf�"�H�\$0H�� A^�@UVWATH��$��H��H��H�=��H3�H�� D�D$dD��H�T$xA��L$`H�U3��3�H�MH�t$0E3��D$(��D$ ��D�F��E3�H�UH��A��H�MH��H��@84u�H�MH�H�MH;�v�8.t@�0H�MH��H;�w�H�M@�0H��f�@8qH�Iu��3��u��f�A�p��A H�M�\��u$�H�"��H��L�EH�L��G��G��H��$��H��L��$8��A��L��$0��Hc�H��Hً��H��H��D��H��H;�s��t �� t�� u�A��@�0H��H��t)��H�T$XH��L��H�H��tL��H��/uA��\��u�H��H��L��H�D$ L��H�T$P��@8t$P��\��H��L��H�D$ L��H�T$PH�M��H��H��@8tH�@u�D��H��A��\uD�A�H�A�HE�A��\t!ff��H��H;�r@�0H�Ȁ8\u�L��H�t$ L��H�T$PH��(��H��H��A��H��L��"��M��u(I�A�O��L��H�6��H��A�G�W��\|$X��L��$@��A�<Lc�L�l$hI�M��I��H�D$XH��H�H�s��~#I�^��@�H��h��H�H�[H��H��u�H�EH��H�À<�u��Hc�H��>��E3�Lc�H�D$pA��"H�x��~lE3�f�B�D5<\u��(<"u!��~�ٲ\D��H��{��H�A��\H��A��B�D5I�ƈH��M;�\|�L�l$h��~�ٲ\D��H��?��H�E3�H�D$pf�"�Hc\|$`H�H��H��~%L�d$x��I��w��H�H��H��H;�\|�\|$d�L�6t5H�T$XI��M��M��H��H��s��H��f�H��A�<�u�L�d$X��I��~-A��f�K��H��D��H��<�u��I��M;�\|�Hcɺ��M��H��H��H��H��H��A�<�u�I��~F��fff��M��H��Hc�H��J��I��H��H��<�u��H��I;�\|�W�D�t$P3��E�h��W�H�E�H� K��EE��PM�M�M�M�M�M�C��H�E�E3�H�D$HE3�H�E�H��H�D$@3�L�t$8L�t$0D�t$(�D$ ��u�H��H��H��J�E��H�M��6��H�M�H�T$P��u�H��H��H�}��D�t$PA��L��$@��L��$8��H��$��L��$0��H�� H3��H��H��A\_^]��H�T$L�D$L�L$ SVWH��0H��H�t$`H�� L��H�t$(H��H�D$ ��L��H��H�H��H�H��0_^[��H��(M�A8H��I�� H��(��@SE�H��A��L��A��L��tA�@McP��L�Hc�L#�Ic�J�H�C�HH�C�Dt�D��L�L3�I��[��ff��H; A5��uH��f��u�H��@SH�� D��ts�7 ��H� l ��uR��tH� ~��m��j��t�U��P��uH�� [ù��H��(�_��3�H��(�H��(�7��H��(�M��H�\$H�t$WH��0��/��6��@2�@�t$ ��؋ �9��#��uJ��9��H��H� �� t ��H�_��H� H�� q9��@�@�t$ ��H��H�8�tH��n��tE3�A�P3�H��H��H�8�tH��B��tH��T �� H�� H�� L��H�Ӌ��tU@��u� ��3ұ��t;�\|$ �u�� H�\$@H�t$HH��0_ù�� H��(��H��(�r��@SH�� H��3��H��H�Ⱥ ��H�� [H�%��H�L$H��8��t��)H� B3��H�D$8H�)4��H�D$8H��H��3��H�4��H��2��H�D$@H��3��]2�� W2��a2��Hk��H� Y2��H��Hk��H� �1��H�L ��Hk�H� �1��H�L H� X��H��8��@SVWH��@H��C��H��3�E3�H�T$`H��H��t9H�d$8�H�L$hH�T$`L��H�L$0L��H�L$pH�L$(3�H�\$ ��ǃ�\|�H��@_^[��H��(��t!eH�%0��H�H�H;�t3��H� �6��u�2�H��(ð��@SH�� 6��ɻ��DÈ�6��u2��u 3��H�� [��@SH�� =l6��ug��wj��t(��u$H� V6��uH� ^6��t.2��3fo��H��%6��H�.6��.6��H�76��6��H�� [ù��^��H��L��MZ��f9 �uxHc <�H��Hʁ9PE��u_��f9AuTL+��QH��H��AH��L��H�$I;�t�JL;�r �B�L;�rH��(��3�H��u2��z$�}2�� 2��2�H��@SH�� 3҅�t��uH�.5��H�� [�@SH�� =#5��t��u�6��/��H�� [��@SH�� H�=�4��H��u�B��H��H� �4��+��3҅�HD�H��H�� [��H��(��H��H��(��H�\$UH��H��0H��.��H�2��-�+��H;�utH�e�H�M�6��H�EH�E�0��H1E�,��H�MH1E�$��EH�M�H�� H3EH3E�H3�H��H#�H�3��-�+��H;�HD�H�Q.��H�\$PH��H�:.��H��0]�3��̸��̸�@��H� )4��H�%��̰��H�!4��H��(��H�$��H�H��(��3�9�-��H�4��H�4��Ã%�3��H�\$UH��$@��H��ٹ��F��t��)��3�H�M�A��H�M�!��H��H��H��E3�� H��t<H�d$8�H��H��L��H�L$0L��H��H�L$(H�M�H�L$ 3�^ ��H��H�L$PH��3�H��A��H��H��t��H��H�D$`�D$P��@�D$T��: ��H�D$PH�D$@H�E��H�D$H3��H�L$@��u��u�H��H��$��H��]��;��H��(3��H��t9�MZ��f9u/HcH<Hȁ9PE��u ��f9Au��v��2�H��(��H� ��H�%b��H�\$WH�� H�H��;csm�u�{u�S ��l�v��@�t H�\$03�H�� _��^��H�H�_�X��H��H�\$WH�� H��H�=��H�H��t�� H��H;�r�H�\$0H�� _�H�\$WH�� H��H�=��H�H��t�� H��H;�r�H�\$0H�� _�H�\$H�t$WH��3�3��D��E3�D��A��ntelA��ineID�ˋ�3�A�CE��A��Genu�$Eщ\$��L$�T$u[H� ���%�?�H����=��t(=`�t!=p�t�� w$H��H��sD��0��A��D��0��D��0��D�H�;�\|&3��$D�ۉ\$�L$�T$�� s E�D�r0��T��D� Q��D� <��5��sy��ss3��H�� H�H�T$ H�D$ "�:�uW�*��)��)��A�� t8�� )��)��D#�D;�uH�D$ $�<�u � �)��@��)��H�\$(3�H�t$0H��_�3�9�)��%2 ��%$ ��%. ��%0 ��%� ��%� ��%� ��%� ��%j ��%� ��%� ��%� ��%� ��%� ��%� ��%� ��%� ��%d ��%n ��%� ��% ��%� ��%� ��%0 ��%2 ��%� ��%6 ��%� ��%� ��%� ��%� ��ff��ff��%� ��@UH�� H��H�H�ы��H�� ]��@UH��H�3Ɂ8��]��0=��>=��Z=��p=��=��=��=��=��A��A��B��"B��@B��TB��C��B��B��B��B��B��B��hB��A��=��=��>��(>��"C��b>��n>�� @��X>�� @��?��@��@@��\@��?��@��?��?��?��\|>��?��n?��>��>��?��?��L?��2?��x@��?��@��?��>��>��>��@��0@��@��>��>��>��!�@��!�@��`'�@��'�@��'�@��D'�@��@��@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.py��Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s��PP�@��P�@��@��P�@��P2�@��`2�@��5�@��X2�@��h2�@��p2�@��x2�@��2�@��'hd�� 5��!��5��,��5��/��D�� "��#��%��&��N&�� '��6��P��.text$mn��P'��6��.text$mn$00��'��6��.text$x��0��P��.idata$5��P2��8��.00cfg��2��.CRT$XCA��2��.CRT$XCAA��2��.CRT$XCZ��2��.CRT$XIA��2��.CRT$XIAA��2��.CRT$XIAC��2��.CRT$XIZ��2��.CRT$XPA��2��.CRT$XPZ��2��.CRT$XTA��2��.CRT$XTZ��2��.rdata��5��\��.rdata$voltmd��5��.rdata$zzzdbg��`8��.rtc$IAA��h8��.rtc$IZZ��p8��.rtc$TAA��x8��.rtc$TZZ��8��.xdata��:��.idata$2��:��.idata$3��:��P��.idata$4��0=��.idata$6��P��@��.data��@P��.bss��`��.pdata��p��`��.rsrc$01��`p��.rsrc$02��Rp`0 �t �d�T�4�2��t�d �T �4�2��B��&��p`P0�� !'�'��4��8��!��L��8��!��L��8��!��8��0��20 �d �4�Rp�&��'��&��8��'��2P � b��rp`0 �"��&��u ��'��u ��P�� 4 � RP�4��P�� 4� 2p�d�4�p��:��=��0��;��F>��0��;��@��1��;��@��0��0<��@��P1��<��A��1��=��>A��02��<��`A��01��<��A�� 1�� <��A��@1��0=��>=��Z=��p=��=��=��=��=��A��A��B��"B��@B��TB��C��B��B��B��B��B��B��hB��A��=��=��>��(>��"C��b>��n>�� @��X>�� @��?��@��@@��\@��?��@��?��?��?��\|>��?��n?��>��>��?��?��L?��2?��x@��?��@��?��>��>��>��@��0@��@��>��>��>��CreateFileA�kGetFinalPathNameByHandleA�WaitForSingleObject�XGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��>�memset��__C_specific_handler��__current_exception��__current_exception_context�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�@�_seh_filter_exe�B�_set_app_type� �__setusermatherr��_configure_narrow_argv��3�_initialize_narrow_environment��(�_get_initial_narrow_environment�6�_initterm�7�_initterm_e�U�exit��#�_exit�T�_set_fmode��_cexit��_c_exit�=�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��4�_initialize_onexit_table��<�_register_onexit_function��_crt_atexit�g�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll��RtlCaptureContext��RtlLookupFunctionEntry��RtlVirtualUnwind��UnhandledExceptionFilter��SetUnhandledExceptionFilter�2GetCurrentProcess��TerminateProcess��IsProcessorFeaturePresent�pQueryPerformanceCounter�3GetCurrentProcessId�7GetCurrentThreadId�� GetSystemTimeAsFileTime��InitializeSListHead��IsDebuggerPresent��GetModuleHandleW��<�memcpy��] �f��2��-�+��4��8��@��8��8��8��8��L��8��L��8��9�� 9��.��8��0��M��8��P��09��89��<9��8��8��@��D9��@��R��8��T��<9��Z��9��\��9�� 8��U��<9��X��<9��\| ��9��\| �� <9�� <9�� !��<9��!��!��8�� !��!��9��"��"��8��@"��#��9��#��#��8��#��S$��9��T$��$��9��$��$��9��$��x&��9��`'��b'��9��'��'��:��'��'��\|9��'��'��9��0�� H��`p��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��0��0��P�X�`�h�p��(�@�H�Ф��	14 KB	2026-01-20 12:58
📄 cli-arm64.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��b��1��1��1��1��1��0��1�x1��1��0��1��0��1��0��1�0��1��1��1��0��1��z1��1��0��1Rich��1��PE��d��'hd��"�$��@��`��8��p��`�� $��4��p3��@��0��.text��4�� `.rdata��0��@��@.data��P��.��@��.pdata�� `��0��@��@.rsrc��p��2��@��@.reloc��$��4��@��B��C��1��1@��c1��_��1��@�1@��c0��T�C��_� ��{��C��{A��_��0��"��@��A��T�_�{��0��"��1��1��@�1@��G�!��>�� (��_��{��5(��!@��4��@��R�?� ��R�{��_��S��{��@��@��?�{��@��SŨ�_��S��[��c��{��i�9��i��4 �8�5�� q��T�"��Q�@�i�9��i��4I�8�5IK)� �!�Q��5��i@�!��\|@��Q�?��a��&��i�9��"��4 �8�5�"��˟�q-�T��@��3��r��ɂ_��9� �j��4 �8�5 K��QU��5��{��cB��[A��Sè�_��R��S��[��c��k��#��{��i�9��i��4 �8�5��i@��?��@��`�9��R��R�?��4��`�8(�@��?֠��5��t�8��4h�@���?�@��4�4�rqa��T��q�T��ra��T_�q��q��~��4���R��r��B6��R��4��8��4���R��h��B6��R��8��(��(��{(��4`�9(�@��?��4��`�8��@��?֠��5h�9H��5��{��#@��kC��cB��[A��SŨ�_��S��[��c��{��i�9��i��4 �8�5˨z�� i@�!��?�X�R��R��9��q��T��Rh�9qqa��T��qa�T��q��T���R��$��B6��R��8��Rh�8��Q��8u��5��q��T���R��B6��y��{��@��cB��[A��SĨ�_�{��S��[��c��k��+��@����* �R��?��@��Rd��R��"��R��R��?��@��R �R��?��9��i��4 �8�5�� (�� )�T�� 9_��q��T�9�� H��T�9��9��j��4�8�5��R�9)� �8i(8��5��R����1a�T��@�@��R�?��@��R� �� �� �� T �9?�q$Jz$Mz!��T�9��A�B�� ?� �4�� !�(@��W�( @��(1�9�� 9�S�� @��9��)�4��R��?��qA��Tj�9 �9I��5��Y@��C��?��C�9h�5��9qq��T��Y@��C��?��9��i��4 �8�5�� �H�� 9?qq��TI��8H ��?qq��T�� T�9 ��8_qqa��T��]@��C��?��i@�!��Ҁ ��?��i@�!��Ҁ ��?��@�� ?֗��@�@��R@��?��a��!��@��R\|��@��ҺH@��i@��?��6#�� q-�T�#��x�Q��`�@��Q��5��"��q �Ts"��Q`�@��Q��5��4��@��?��@�@��R�?�� @��RG����O��!��R��=��OA��A�A�a�� R�C��a��@��?��@��R$��R��?�@�5��@�@��R�?��A ��R��3@�(�� !�� @��@��?�� @��@��S��?�@�5��@�@��R�?�� R��@��f��+@��kD��cC��[B��SA��{ƨ�_��S��{��~��@��@��@��?��q��Z�{��@��SŨ�_��#�{��h@�� ~�(ia�(��!��L�� R�{��#�_��#��{�� R���� R��S��42��!�k��5��4�� }��SH��4{��5�{��A��#�_��R��>��#�{��R�{��#�_�#�{��{��#�_��#��S��{�� R��SH�4��R�C�9i��S3��h@��q� �Th�5(��Rh�� ! �N��`��4��RB�� C��H��Rh��5��R�C�9���h@��SH�4h@��A��R��1 A� ?��?�t��h@��Sh��4`@�8��@��@��E��i��S(�4U��5#��R ��R��* ��^��S�4�C@9H��5���{¨�@��S¨�#�_��RM��RK������>��#�{��{��#�_�#�{��4�� @�(�� ?�`�TH�_�h��I�ȱ��5�;�(��R�{��#�_� ��R��#�{��)��(�@9��q�(��9��Sh��5��R��S��5��R�� R�{��#�_�#��S��{��3��h�A9��h�5��q��T��4t�5(��5(��A��4��R ��(�� %�� (��A� %�� (��Rh�9 ��R�{��S��#�_֠��R��>�#�{��I�R��h@y k��Th=@�j�(� ��RH@� k!�TH1@y-q��T��H)@y �a��I @y ��+! ��@�T @��A��T @�) �A)��T��h��R ��%@�h��6��R�� R��R��R�{¨�#�_��#��{��S1��4��5��ȿ;�{��A��#�_�#��{��@9�S)�SH��4��5�c��a�� R�{��A��#�_��#��{�� (@��a��TY�� R��q`��{��A��#�_�#�{��Z�{��#�_��#��S��{��h@��X��T��)@��c��?��@��%@��?��@� \|@�(��!@��?��@� \|@��(��-@��?��@��#@� � ��@�)��C��(� �@�?��X��h��(�� {è�S��#�_� �2��-�+��3��-�+��R�_� ��R�_��R�_��1@��_��_��#�{�� @�(��@��{��#�_��@��q��_��A��_��!��_��`�>�_��#�{��9@��?֠��@y�I�R k!�T<@� ��R �(�H@� ka�TH1@y-q�TH�@�9�q��TH�@��q��R�{��#�_��!��5@��#��S��{��@��h@� k��Th@��q!�Ti"@��(K �q)�TH�?k��T��R�{��S��#�_�Q��@�Q��>� �csm� ��@��#��S��{�� (!��3!��B�Th�@��1 A� ?��?��T�{��S��#�_��#��S��{�� (!��3!��B�Th�@��1 A� ?��?��T�{��S��#�_��C��@��R`�>�C��_��@��q��_��F@��B@��J@��N@��@��@��@��@��z@��@��@��@��@��@��@��@��@��@��@��@��r@��f@��@��@��@��@��@��@��@��@��R@��#�{��(�@��@�� {��#�_�a��#�{��@� @��?k��{��#�_�a��;��;��;��;��<��<��.<��F<��^@��t@��@��D@��@��@��@��z<��p<��<��<��@��<��<��>��<��>��=��?��>��H>��R>��\>��=��=��>��>��>��2>��?��<�� =��>��=��=��\|=��>��D=��?��,?��$?��=��=��>��:>��r=��h=��^=��"�@��@��&�@��8�@��X�@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.py��Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s��P�@��0Q�@��@��P�@��2�@��2�@�� 2�@��(2�@��'hd�� h��5��!��.text��.text$mn��&��d��.text$x��0��.idata$5��2�� .00cfg��02��.CRT$XCA��82��.CRT$XCAA��@2��.CRT$XCZ��H2��.CRT$XIA��P2��.CRT$XIAA��X2��.CRT$XIAC��`2��.CRT$XIZ��h2��.CRT$XPA��p2��.CRT$XPZ��x2��.CRT$XTA��2��.CRT$XTZ��2��p��.rdata��5��h��.rdata$zzzdbg��h7��.rtc$IAA��p7��.rtc$IZZ��x7��.rtc$TAA��7��.rtc$TZZ��7��8��.xdata��8��.idata$2��9��.idata$3��9��.idata$4��;��F��.idata$6��P�� .data�� P��.bss��`�� .pdata��p��`��.rsrc$01��`p��.rsrc$02��`"��Ђ�Ђ��`"��Ђ�Ђ��^0 �� Ɉ�Ȅ��@��@�@��@��B�B��/�@(�@��k�P]�@��Ђ$��h%��&��&��@��@�@��5�p��h%��\ ��'��\ �� @��@�@���@#�@��"��%�@�@��"��9��b<��0�� :��<��0��h:��6?��0��P:��V?��0��:��\|?��1��H;��?��1��;��?��1��:��?��0��:��@��0��:��"@��1��;��;��;��;��<��<��.<��F<��^@��t@��@��D@��@��@��@��z<��p<��<��<��@��<��<��>��<��>��=��?��>��H>��R>��\>��=��=��>��>��>��2>��?��<�� =��>��=��=��\|=��>��D=��?��,?��$?��*=��=��>��:>��r=��h=��^=��CreateFileA�iGetFinalPathNameByHandleA�WaitForSingleObject�VGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��=�memset��__C_specific_handler��__current_exception��__current_exception_context�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�@�_seh_filter_exe�B�_set_app_type� �__setusermatherr��_configure_narrow_argv��3�_initialize_narrow_environment��(�_get_initial_narrow_environment�6�_initterm�7�_initterm_e�U�exit��#�_exit�T�_set_fmode��_cexit��_c_exit�=�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��4�_initialize_onexit_table��<�_register_onexit_function��_crt_atexit�g�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll�kQueryPerformanceCounter�2GetCurrentProcessId�6GetCurrentThreadId��GetSystemTimeAsFileTime��InitializeSListHead��SetUnhandledExceptionFilter��GetModuleHandleW��;�memcpy��] �f��2��-�+��7�� 7��P��7��p��L8��X8��8��5��7��p��%f��i0��0��7��7��=��X��7��!��8��%��`��8��!��0��8��a��8��`8��p ��A�A� ��M�A�!��Q�AP!��%��x!��B�"��=��0#��#��8��`$��e�B�$��e�B0%��&��@8��'��8��0�� H��`p��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��0��$��(�8�P�X�X�`�ȣ�裠��	13.5 KB	2026-01-20 12:58
📄 cli.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��z 2�da�da�da�c�a�dasee`�dase�a�dasea`�dase``�daseg`�da�ce`�da�ea�da�d``�da�d�a�da�df`�daRich�da��PE��L��'hd��$��0��@��p��@��6��P��`��2��2��@��0��.text�� `.rdata�� 0��@��@.data��@��(��@��.rsrc��P����@��@.reloc��`��,��@��B��C@��U��}�u�@@��t j�P�0@��]��U��EPj��u�u��p�0��1@��]��U��j��u�u��]��U��S�]VW�K��C��u�+�j�]��P�x0@��ȃ��M�3��"�q3ɉM��~S�U�<\uG�&<"u ��~Wj\V��M��U�3��\F�3��A�F�M�;�\|�~Wj\V�t��E�_f�"�^[��]��U��@@�3ŉE��E��E��h��Pj��0@�j�h��jj�jh��P��0@�j�h��QP�0@��Q�A��u�+ʍ��;�v�8.t��H;�w퍍��If��A�I��u��1@��1@��Af��1@�f�A��1@�W�A ��j�P��u2��Ph�1@�j��0@��P��G_�M�3��]�Vh��PW��W��H@;�s��t �� t�� u�j��h�1@�P�1@��t&��1@��~�1@��1@�fօ��΍Q�A��u�S+�jQ�x0@��3ۉ��Q��1@��tD��FFP�1@��u�F��P�1@��t��tm��\uC�ƀ�"u0�Ã��u 3��3��9��EȈ��tSj\W��3ۊ��o��G�g��tSj\W��3ۋ��@��G��<�t-�P�1@��t�FFP�1@��u�>��;�Ǌ��t��@��/u�\��u�5h0@��P��P��P��PW�փ��\��P��P��P��P��P�֍��Q�A��u�+ʊ� �� Ӏ�\u�Q�3��\��\tf��;�r ��H�8\u�j�W��P��P��P�l0@��=x0@�jh��׋��h��PV��1@��(�,�x0@�jh��h��WV�1@��=x0@��u/�3h�1@�j��0@��P�r��F[^_�M�3��Q��]Ë��j� ��A�P�׋�V��~��{��9��~��4��R��C��;�\|勵��P�3��9��~/��4��C��;�\|勵��}��t@��V��0@��Vh�1@�j��0@��P�l��[^_�M�3��I��]Ë΍Q�A��u��+ʺ��y;�~0�󐋅��Y@��A��u�+�GB�;�\|ߋ��x0@�jW��Vh�1@�P��N��F��u��+�;�~O@�ff��4��h�1@�P�d��QD��A��u�+�FG�;�\|�W�ǅ��jh@��ǅ��D��f��f��f��f��f��f��f��f��0@��P��Pj�j�j�jj�j��j��0@��u,hP1@�j��0@��P��3�[^_�M�3��]Ë��j��@@��0@��P��0@��u,hl1@�j��0@��P�v��3�[^_�M�3��V��]ËM��3�[^_�?��]��U��EPj��uj��u��p��Q��0@��H�]�; @@�u��y��Vj�v��V��P��D��j�0��^��ts��l��h"@��n��P�>��YY��uQ��c��th�@��Y�)��$��P�G��Y��t� ��T��u�j�-��3��P��Y�jh�5@��/��j��Y��P��2ۈ]�e��Eܡ<C@�3�A;��/��uI� <C@�h<1@�h01@�� YY��t�E��h,1@�h$1@��[ ��YY�<C@��و]�u��Y�i��3�9>tV�9��Y��t�6WjW��1@��G��9>tV��Y��t�6�$ ��Y�� 0� ��WV�0�q��.��tk��u�� j�j�{��YY�E��5�M��E�QP�{ ��YYËe��t2�}��u� ��E��E�M�d� ��Y_^[��j��V�j ��u��h ��t��U��j��D0@��u�H0@�h ��@0@�P�<0@�]�U��$��j�80@��tjY�)� A@�� A@��A@��A@��5A@��=A@�f�8A@�f� ,A@�f�A@�f�A@�f�%�A@�f�-�@@��0A@��E��$A@��E�(A@��E�4A@��p@@��(A@��,@@�� @@� ��$@@��0@@��jXk��ǀ4@@��jXk�� @@��L�jX�� @@��L�h2@��U��EV�H<��A�Q��Ak�(�;�t�M;Jr �BB;�r��(;�u�3�^]Ë��V��t d��@C@��P�;�t3��u�2�^ð^�U��}�u�DC@��v��r��u2�]��e��u j��Z��Y��]�U��=EC@��t�]�V�u��t��ub��t&��u"hHC@��Y��uhTC@��y��Y��t+2��0�� HC@�� LC@�� PC@�� TC@�� XC@�� \C@��EC@��^]�j�/��jh�6@��K��e��MZ��f9��@�u]�<�@��@�PE��uL��f9��@�u>�E��@�+�PQ�\|��YY��t'�x$�\|!�E��E��3Ɂ8��Ëe��E��2��M�d� ��Y_^[��U��t�}�u 3��@C@��]�U��=DC@��t�}�u�u��u��YY�]�U��=HC@��uu�T��hHC@��B��Y��Y��#E]�U��u��Y��H]�U��e��E�e��P�(0@��E�3E�E��,0@�1E��00@�1E��E�P�40@��E�M�3E�3E�3��Ë @@�VW�N�@��;�t��u&��;�u�O�@��u G��ȉ @@��_� �@@�^�3��3�@ø�@��h`C@��$0@�ð�h��h��j��g��u�j�?��hC@��H�$�H��H��H�3�9@@��ø�C@�ø�C@��U��$��Sj�80@��t�M�)j��$��j�P�F��\|��x��f��f��f��t��f��p��f��l��f��h��E��E��ǅ��@�jP��E�j�P��E��E��@�E��E�� 0@�j��X��ۍE��E��ۉE��D0@��E�P�H0@��u��uj��Y[��e��j��L0@��t3�MZ��f9u)�H<ȁ9PE��u��f9Au�ytv��2��h�!@��D0@��U��VW�}�7�>csm�u%�~u�F= �t=!�t="�t=�@�t_3�^]��0�w��0�\��̃%pC@��SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[�SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[��h�"@�d�5��D$�l$�l$+�SVW�@@�1E�3�P�e�u��E��E��E��E�d��U��V�u�6��u��u�uVh2@�h@@��^]�U��%tC@��$� @@�j �80@��e��3�SVW3ɍ}�S��[��w�O3ɉW�E܋}�E�Genu�E�5ineI�E��E�5ntel�E�3�@S��[��]܉�E�E�ǉs�K�SuC�E�%�?�=��t#=`�t=p�t=P�t=`�t=p�u�=xC@��=xC@��=xC@��M�jX�M�9E�\|03�S��[��]܉�s�K�M��S�]��t��=xC@��]�@@��tC@��@@��tC@��@@��ty��tq3�ЉE�U�E�M�j^#�;�uW�@@��tC@��@@�� t;�� tC@��@@��#�;�u�E��M�#�;�u � @@�@�5tC@�_^[3��3�9@@��%T0@��%X0@��%`0@��%\0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%1@��%�0@��%�0@��%�0@��%�0@��%t0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@�U��Q�=tC@�\|f�}��t �}��uT�]��E��?��t?��u��é��t��u��é��u��é ��u��ø��ËE��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��@��@��@@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.py��Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s�� @@�p@@��@@��3@��1@��3@�� 1@��'hd�� l��`3��`��"��3��,��H3��"��(#��#��$��$��$��$��c$��k$��@��"��N%��x��.text$mn��0��.idata$5��1��.00cfg��$1��.CRT$XCA��(1��.CRT$XCAA��,1��.CRT$XCZ��01��.CRT$XIA��41��.CRT$XIAA��81��.CRT$XIAC��<1��.CRT$XIZ��@1��.CRT$XPA��D1��.CRT$XPZ��H1��.CRT$XTA��L1��.CRT$XTZ��P1��.rdata��3��.rdata$sxdata��3��\��.rdata$voltmd��`3��l��.rdata$zzzdbg��5��.rtc$IAA��5��.rtc$IZZ��5��.rtc$TAA��5��.rtc$TZZ��5��<��.xdata$x��6��.idata$2��6��.idata$3��6��.idata$4��8��.idata$6��@��.data��@��x��.bss��P��`��.rsrc$01��`P��.rsrc$02��,@�@@��N@�a@��6��8��0��L7��,9��T0��l7��;��t0��`7��;��h0��7��;��0��7��<��0��8��4<��1��7��V<��0��x7��v<��0��7��<��0��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��CreateFileA�dGetFinalPathNameByHandleA��WaitForSingleObject�QGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��H�memset��__current_exception��__current_exception_context�5�_except_handler4_common�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�B�_seh_filter_exe�D�_set_app_type�.�__setusermatherr��_configure_narrow_argv��5�_initialize_narrow_environment���_get_initial_narrow_environment�8�_initterm�9�_initterm_e�X�exit��%�_exit�T�_set_fmode��_cexit��_c_exit�?�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��6�_initialize_onexit_table��>�_register_onexit_function��_crt_atexit��_controlfp_s��j�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll��UnhandledExceptionFilter��SetUnhandledExceptionFilter�,GetCurrentProcess��TerminateProcess��IsProcessorFeaturePresent�mQueryPerformanceCounter�-GetCurrentProcessId�1GetCurrentThreadId��GetSystemTimeAsFileTime��InitializeSListHead��IsDebuggerPresent��GetModuleHandleW��DN�@��0�� H��`P��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��00'0[0�0J1u1�1�1�1222<2D2�2�2�2�2�2303H3j3)4<4s4M5S5w5�5�5�5�5�5�6�6�6>7I7�7�7(8P8Y8a8�8�8�8�8�8!949x9�9:3:H:M:R:s:x:�:�:�;�;�;�;�;�;�;�;�;�;�;�;�<<<<<#<+<3<;<G<P<U<[<e<o<<�<�<�<=4=g=�=�=�=�=�=�=�=�=�=�=>>> >>�>�>�>�>?'?0?=?S?�?�?�?�?�?�� 000%0�011;1z1�1�1�1�1�1222A2^2�2�2�2�2�2u3~3�3�3�3�3�3�3�3+444=4K4T4v4}4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�455555 5&5,52585>5D5J5T5��0��(��1(1418122L2P2X2�2�2�5�566��	11.5 KB	2026-01-20 12:58
📁 command	-	2026-03-21 15:45
📁 compat	-	2026-03-21 15:45
📁 config	-	2026-03-21 15:45
📄 depends.py from __future__ import annotations import contextlib import dis import marshal import sys from types import CodeType from typing import Any, Literal, TypeVar from packaging.version import Version from . import _imp from ._imp import PY_COMPILED, PY_FROZEN, PY_SOURCE, find_module _T = TypeVar("_T") __all__ = ['Require', 'find_module'] class Require: """A prerequisite to building or installing a distribution""" def __init__( self, name, requested_version, module, homepage: str = '', attribute=None, format=None, ) -> None: if format is None and requested_version is not None: format = Version if format is not None: requested_version = format(requested_version) if attribute is None: attribute = '__version__' self.__dict__.update(locals()) del self.self def full_name(self): """Return full package/distribution name, w/version""" if self.requested_version is not None: return f'{self.name}-{self.requested_version}' return self.name def version_ok(self, version): """Is 'version' sufficiently up-to-date?""" return ( self.attribute is None or self.format is None or str(version) != "unknown" and self.format(version) >= self.requested_version ) def get_version( self, paths=None, default: _T \| Literal["unknown"] = "unknown" ) -> _T \| Literal["unknown"] \| None \| Any: """Get version number of installed module, 'None', or 'default' Search 'paths' for module. If not found, return 'None'. If found, return the extracted version attribute, or 'default' if no version attribute was specified, or the value cannot be determined without importing the module. The version is formatted according to the requirement's version format (if any), unless it is 'None' or the supplied 'default'. """ if self.attribute is None: try: f, _p, _i = find_module(self.module, paths) except ImportError: return None if f: f.close() return default v = get_module_constant(self.module, self.attribute, default, paths) if v is not None and v is not default and self.format is not None: return self.format(v) return v def is_present(self, paths=None): """Return true if dependency is present on 'paths'""" return self.get_version(paths) is not None def is_current(self, paths=None): """Return true if dependency is present and up-to-date on 'paths'""" version = self.get_version(paths) if version is None: return False return self.version_ok(str(version)) def maybe_close(f): @contextlib.contextmanager def empty(): yield return if not f: return empty() return contextlib.closing(f) # Some objects are not available on some platforms. # XXX it'd be better to test assertions about bytecode instead. if not sys.platform.startswith('java') and sys.platform != 'cli': def get_module_constant( module, symbol, default: _T \| int = -1, paths=None ) -> _T \| int \| None \| Any: """Find 'module' by searching 'paths', and extract 'symbol' Return 'None' if 'module' does not exist on 'paths', or it does not define 'symbol'. If the module defines 'symbol' as a constant, return the constant. Otherwise, return 'default'.""" try: f, path, (_suffix, _mode, kind) = info = find_module(module, paths) except ImportError: # Module doesn't exist return None with maybe_close(f): if kind == PY_COMPILED: f.read(8) # skip magic & date code = marshal.load(f) elif kind == PY_FROZEN: code = _imp.get_frozen_object(module, paths) elif kind == PY_SOURCE: code = compile(f.read(), path, 'exec') else: # Not something we can parse; we'll have to import it. :( imported = _imp.get_module(module, paths, info) return getattr(imported, symbol, None) return extract_constant(code, symbol, default) def extract_constant( code: CodeType, symbol: str, default: _T \| int = -1 ) -> _T \| int \| None \| Any: """Extract the constant value of 'symbol' from 'code' If the name 'symbol' is bound to a constant value by the Python code object 'code', return that value. If 'symbol' is bound to an expression, return 'default'. Otherwise, return 'None'. Return value is based on the first assignment to 'symbol'. 'symbol' must be a global, or at least a non-"fast" local in the code block. That is, only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol' must be present in 'code.co_names'. """ if symbol not in code.co_names: # name's not there, can't possibly be an assignment return None name_idx = list(code.co_names).index(symbol) STORE_NAME = dis.opmap['STORE_NAME'] STORE_GLOBAL = dis.opmap['STORE_GLOBAL'] LOAD_CONST = dis.opmap['LOAD_CONST'] const = default for byte_code in dis.Bytecode(code): op = byte_code.opcode arg = byte_code.arg if op == LOAD_CONST: assert arg is not None const = code.co_consts[arg] elif arg == name_idx and (op == STORE_NAME or op == STORE_GLOBAL): return const else: const = default return None __all__ += ['get_module_constant', 'extract_constant']	5.83 KB	2026-01-20 12:58
📄 discovery.py """Automatic discovery of Python modules and packages (for inclusion in the distribution) and other config values. For the purposes of this module, the following nomenclature is used: - "src-layout": a directory representing a Python project that contains a "src" folder. Everything under the "src" folder is meant to be included in the distribution when packaging the project. Example:: . ├── tox.ini ├── pyproject.toml └── src/ └── mypkg/ ├── __init__.py ├── mymodule.py └── my_data_file.txt - "flat-layout": a Python project that does not use "src-layout" but instead have a directory under the project root for each package:: . ├── tox.ini ├── pyproject.toml └── mypkg/ ├── __init__.py ├── mymodule.py └── my_data_file.txt - "single-module": a project that contains a single Python script direct under the project root (no directory used):: . ├── tox.ini ├── pyproject.toml └── mymodule.py """ from __future__ import annotations import itertools import os from collections.abc import Iterable, Iterator, Mapping from fnmatch import fnmatchcase from glob import glob from pathlib import Path from typing import TYPE_CHECKING, ClassVar import _distutils_hack.override # noqa: F401 from ._path import StrPath from distutils import log from distutils.util import convert_path if TYPE_CHECKING: from setuptools import Distribution chain_iter = itertools.chain.from_iterable def _valid_name(path: StrPath) -> bool: # Ignore invalid names that cannot be imported directly return os.path.basename(path).isidentifier() class _Filter: """ Given a list of patterns, create a callable that will be true only if the input matches at least one of the patterns. """ def __init__(self, patterns: str) -> None: self._patterns = dict.fromkeys(patterns) def __call__(self, item: str) -> bool: return any(fnmatchcase(item, pat) for pat in self._patterns) def __contains__(self, item: str) -> bool: return item in self._patterns class _Finder: """Base class that exposes functionality for module/package finders""" ALWAYS_EXCLUDE: ClassVar[tuple[str, ...]] = () DEFAULT_EXCLUDE: ClassVar[tuple[str, ...]] = () @classmethod def find( cls, where: StrPath = '.', exclude: Iterable[str] = (), include: Iterable[str] = ('',), ) -> list[str]: """Return a list of all Python items (packages or modules, depending on the finder implementation) found within directory 'where'. 'where' is the root directory which will be searched. It should be supplied as a "cross-platform" (i.e. URL-style) path; it will be converted to the appropriate local path syntax. 'exclude' is a sequence of names to exclude; '' can be used as a wildcard in the names. When finding packages, 'foo.' will exclude all subpackages of 'foo' (but not 'foo' itself). 'include' is a sequence of names to include. If it's specified, only the named items will be included. If it's not specified, all found items will be included. 'include' can contain shell style wildcard patterns just like 'exclude'. """ exclude = exclude or cls.DEFAULT_EXCLUDE return list( cls._find_iter( convert_path(str(where)), _Filter(cls.ALWAYS_EXCLUDE, exclude), _Filter(include), ) ) @classmethod def _find_iter( cls, where: StrPath, exclude: _Filter, include: _Filter ) -> Iterator[str]: raise NotImplementedError class PackageFinder(_Finder): """ Generate a list of all Python packages found within a directory """ ALWAYS_EXCLUDE = ("ez_setup", "__pycache__") @classmethod def _find_iter( cls, where: StrPath, exclude: _Filter, include: _Filter ) -> Iterator[str]: """ All the packages found in 'where' that pass the 'include' filter, but not the 'exclude' filter. """ for root, dirs, files in os.walk(str(where), followlinks=True): # Copy dirs to iterate over it, then empty dirs. all_dirs = dirs[:] dirs[:] = [] for dir in all_dirs: full_path = os.path.join(root, dir) rel_path = os.path.relpath(full_path, where) package = rel_path.replace(os.path.sep, '.') # Skip directory trees that are not valid packages if '.' in dir or not cls._looks_like_package(full_path, package): continue # Should this package be included? if include(package) and not exclude(package): yield package # Early pruning if there is nothing else to be scanned if f"{package}" in exclude or f"{package}." in exclude: continue # Keep searching subdirectories, as there may be more packages # down there, even if the parent was excluded. dirs.append(dir) @staticmethod def _looks_like_package(path: StrPath, _package_name: str) -> bool: """Does a directory look like a package?""" return os.path.isfile(os.path.join(path, '__init__.py')) class PEP420PackageFinder(PackageFinder): @staticmethod def _looks_like_package(_path: StrPath, _package_name: str) -> bool: return True class ModuleFinder(_Finder): """Find isolated Python modules. This function will not recurse subdirectories. """ @classmethod def _find_iter( cls, where: StrPath, exclude: _Filter, include: _Filter ) -> Iterator[str]: for file in glob(os.path.join(where, ".py")): module, _ext = os.path.splitext(os.path.basename(file)) if not cls._looks_like_module(module): continue if include(module) and not exclude(module): yield module _looks_like_module = staticmethod(_valid_name) # We have to be extra careful in the case of flat layout to not include files # and directories not meant for distribution (e.g. tool-related) class FlatLayoutPackageFinder(PEP420PackageFinder): _EXCLUDE = ( "ci", "bin", "debian", "doc", "docs", "documentation", "manpages", "news", "newsfragments", "changelog", "test", "tests", "unit_test", "unit_tests", "example", "examples", "scripts", "tools", "util", "utils", "python", "build", "dist", "venv", "env", "requirements", # ---- Task runners / Build tools ---- "tasks", # invoke "fabfile", # fabric "site_scons", # SCons # ---- Other tools ---- "benchmark", "benchmarks", "exercise", "exercises", "htmlcov", # Coverage.py # ---- Hidden directories/Private packages ---- "[._]", ) DEFAULT_EXCLUDE = tuple(chain_iter((p, f"{p}.") for p in _EXCLUDE)) """Reserved package names""" @staticmethod def _looks_like_package(_path: StrPath, package_name: str) -> bool: names = package_name.split('.') # Consider PEP 561 root_pkg_is_valid = names[0].isidentifier() or names[0].endswith("-stubs") return root_pkg_is_valid and all(name.isidentifier() for name in names[1:]) class FlatLayoutModuleFinder(ModuleFinder): DEFAULT_EXCLUDE = ( "setup", "conftest", "test", "tests", "example", "examples", "build", # ---- Task runners ---- "toxfile", "noxfile", "pavement", "dodo", "tasks", "fabfile", # ---- Other tools ---- "[Ss][Cc]onstruct", # SCons "conanfile", # Connan: C/C++ build tool "manage", # Django "benchmark", "benchmarks", "exercise", "exercises", # ---- Hidden files/Private modules ---- "[._]", ) """Reserved top-level module names""" def _find_packages_within(root_pkg: str, pkg_dir: StrPath) -> list[str]: nested = PEP420PackageFinder.find(pkg_dir) return [root_pkg] + [".".join((root_pkg, n)) for n in nested] class ConfigDiscovery: """Fill-in metadata and options that can be automatically derived (from other metadata/options, the file system or conventions) """ def __init__(self, distribution: Distribution) -> None: self.dist = distribution self._called = False self._disabled = False self._skip_ext_modules = False def _disable(self): """Internal API to disable automatic discovery""" self._disabled = True def _ignore_ext_modules(self): """Internal API to disregard ext_modules. Normally auto-discovery would not be triggered if ``ext_modules`` are set (this is done for backward compatibility with existing packages relying on ``setup.py`` or ``setup.cfg``). However, ``setuptools`` can call this function to ignore given ``ext_modules`` and proceed with the auto-discovery if ``packages`` and ``py_modules`` are not given (e.g. when using pyproject.toml metadata). """ self._skip_ext_modules = True @property def _root_dir(self) -> StrPath: # The best is to wait until `src_root` is set in dist, before using _root_dir. return self.dist.src_root or os.curdir @property def _package_dir(self) -> dict[str, str]: if self.dist.package_dir is None: return {} return self.dist.package_dir def __call__( self, force: bool = False, name: bool = True, ignore_ext_modules: bool = False ): """Automatically discover missing configuration fields and modifies the given ``distribution`` object in-place. Note that by default this will only have an effect the first time the ``ConfigDiscovery`` object is called. To repeatedly invoke automatic discovery (e.g. when the project directory changes), please use ``force=True`` (or create a new ``ConfigDiscovery`` instance). """ if force is False and (self._called or self._disabled): # Avoid overhead of multiple calls return self._analyse_package_layout(ignore_ext_modules) if name: self.analyse_name() # depends on ``packages`` and ``py_modules`` self._called = True def _explicitly_specified(self, ignore_ext_modules: bool) -> bool: """``True`` if the user has specified some form of package/module listing""" ignore_ext_modules = ignore_ext_modules or self._skip_ext_modules ext_modules = not (self.dist.ext_modules is None or ignore_ext_modules) return ( self.dist.packages is not None or self.dist.py_modules is not None or ext_modules or hasattr(self.dist, "configuration") and self.dist.configuration # ^ Some projects use numpy.distutils.misc_util.Configuration ) def _analyse_package_layout(self, ignore_ext_modules: bool) -> bool: if self._explicitly_specified(ignore_ext_modules): # For backward compatibility, just try to find modules/packages # when nothing is given return True log.debug( "No `packages` or `py_modules` configuration, performing " "automatic discovery." ) return ( self._analyse_explicit_layout() or self._analyse_src_layout() # flat-layout is the trickiest for discovery so it should be last or self._analyse_flat_layout() ) def _analyse_explicit_layout(self) -> bool: """The user can explicitly give a package layout via ``package_dir``""" package_dir = self._package_dir.copy() # don't modify directly package_dir.pop("", None) # This falls under the "src-layout" umbrella root_dir = self._root_dir if not package_dir: return False log.debug(f"`explicit-layout` detected -- analysing {package_dir}") pkgs = chain_iter( _find_packages_within(pkg, os.path.join(root_dir, parent_dir)) for pkg, parent_dir in package_dir.items() ) self.dist.packages = list(pkgs) log.debug(f"discovered packages -- {self.dist.packages}") return True def _analyse_src_layout(self) -> bool: """Try to find all packages or modules under the ``src`` directory (or anything pointed by ``package_dir[""]``). The "src-layout" is relatively safe for automatic discovery. We assume that everything within is meant to be included in the distribution. If ``package_dir[""]`` is not given, but the ``src`` directory exists, this function will set ``package_dir[""] = "src"``. """ package_dir = self._package_dir src_dir = os.path.join(self._root_dir, package_dir.get("", "src")) if not os.path.isdir(src_dir): return False log.debug(f"`src-layout` detected -- analysing {src_dir}") package_dir.setdefault("", os.path.basename(src_dir)) self.dist.package_dir = package_dir # persist eventual modifications self.dist.packages = PEP420PackageFinder.find(src_dir) self.dist.py_modules = ModuleFinder.find(src_dir) log.debug(f"discovered packages -- {self.dist.packages}") log.debug(f"discovered py_modules -- {self.dist.py_modules}") return True def _analyse_flat_layout(self) -> bool: """Try to find all packages and modules under the project root. Since the ``flat-layout`` is more dangerous in terms of accidentally including extra files/directories, this function is more conservative and will raise an error if multiple packages or modules are found. This assumes that multi-package dists are uncommon and refuse to support that use case in order to be able to prevent unintended errors. """ log.debug(f"`flat-layout` detected -- analysing {self._root_dir}") return self._analyse_flat_packages() or self._analyse_flat_modules() def _analyse_flat_packages(self) -> bool: self.dist.packages = FlatLayoutPackageFinder.find(self._root_dir) top_level = remove_nested_packages(remove_stubs(self.dist.packages)) log.debug(f"discovered packages -- {self.dist.packages}") self._ensure_no_accidental_inclusion(top_level, "packages") return bool(top_level) def _analyse_flat_modules(self) -> bool: self.dist.py_modules = FlatLayoutModuleFinder.find(self._root_dir) log.debug(f"discovered py_modules -- {self.dist.py_modules}") self._ensure_no_accidental_inclusion(self.dist.py_modules, "modules") return bool(self.dist.py_modules) def _ensure_no_accidental_inclusion(self, detected: list[str], kind: str): if len(detected) > 1: from inspect import cleandoc from setuptools.errors import PackageDiscoveryError msg = f"""Multiple top-level {kind} discovered in a flat-layout: {detected}. To avoid accidental inclusion of unwanted files or directories, setuptools will not proceed with this build. If you are trying to create a single distribution with multiple {kind} on purpose, you should not rely on automatic discovery. Instead, consider the following options: 1. set up custom discovery (`find` directive with `include` or `exclude`) 2. use a `src-layout` 3. explicitly set `py_modules` or `packages` with a list of names To find more information, look for "package discovery" on setuptools docs. """ raise PackageDiscoveryError(cleandoc(msg)) def analyse_name(self) -> None: """The packages/modules are the essential contribution of the author. Therefore the name of the distribution can be derived from them. """ if self.dist.metadata.name or self.dist.name: # get_name() is not reliable (can return "UNKNOWN") return log.debug("No `name` configuration, performing automatic discovery") name = ( self._find_name_single_package_or_module() or self._find_name_from_packages() ) if name: self.dist.metadata.name = name def _find_name_single_package_or_module(self) -> str \| None: """Exactly one module or package""" for field in ('packages', 'py_modules'): items = getattr(self.dist, field, None) or [] if items and len(items) == 1: log.debug(f"Single module/package detected, name: {items[0]}") return items[0] return None def _find_name_from_packages(self) -> str \| None: """Try to find the root package that is not a PEP 420 namespace""" if not self.dist.packages: return None packages = remove_stubs(sorted(self.dist.packages, key=len)) package_dir = self.dist.package_dir or {} parent_pkg = find_parent_package(packages, package_dir, self._root_dir) if parent_pkg: log.debug(f"Common parent package detected, name: {parent_pkg}") return parent_pkg log.warn("No parent package detected, impossible to derive `name`") return None def remove_nested_packages(packages: list[str]) -> list[str]: """Remove nested packages from a list of packages. >>> remove_nested_packages(["a", "a.b1", "a.b2", "a.b1.c1"]) ['a'] >>> remove_nested_packages(["a", "b", "c.d", "c.d.e.f", "g.h", "a.a1"]) ['a', 'b', 'c.d', 'g.h'] """ pkgs = sorted(packages, key=len) top_level = pkgs[:] size = len(pkgs) for i, name in enumerate(reversed(pkgs)): if any(name.startswith(f"{other}.") for other in top_level): top_level.pop(size - i - 1) return top_level def remove_stubs(packages: list[str]) -> list[str]: """Remove type stubs (:pep:`561`) from a list of packages. >>> remove_stubs(["a", "a.b", "a-stubs", "a-stubs.b.c", "b", "c-stubs"]) ['a', 'a.b', 'b'] """ return [pkg for pkg in packages if not pkg.split(".")[0].endswith("-stubs")] def find_parent_package( packages: list[str], package_dir: Mapping[str, str], root_dir: StrPath ) -> str \| None: """Find the parent package that is not a namespace.""" packages = sorted(packages, key=len) common_ancestors = [] for i, name in enumerate(packages): if not all(n.startswith(f"{name}.") for n in packages[i + 1 :]): # Since packages are sorted by length, this condition is able # to find a list of all common ancestors. # When there is divergence (e.g. multiple root packages) # the list will be empty break common_ancestors.append(name) for name in common_ancestors: pkg_path = find_package_path(name, package_dir, root_dir) init = os.path.join(pkg_path, "__init__.py") if os.path.isfile(init): return name return None def find_package_path( name: str, package_dir: Mapping[str, str], root_dir: StrPath ) -> str: """Given a package name, return the path where it should be found on disk, considering the ``package_dir`` option. >>> path = find_package_path("my.pkg", {"": "root/is/nested"}, ".") >>> path.replace(os.sep, "/") './root/is/nested/my/pkg' >>> path = find_package_path("my.pkg", {"my": "root/is/nested"}, ".") >>> path.replace(os.sep, "/") './root/is/nested/pkg' >>> path = find_package_path("my.pkg", {"my.pkg": "root/is/nested"}, ".") >>> path.replace(os.sep, "/") './root/is/nested' >>> path = find_package_path("other.pkg", {"my.pkg": "root/is/nested"}, ".") >>> path.replace(os.sep, "/") './other/pkg' """ parts = name.split(".") for i in range(len(parts), 0, -1): # Look backwards, the most specific package_dir first partial_name = ".".join(parts[:i]) if partial_name in package_dir: parent = package_dir[partial_name] return os.path.join(root_dir, parent, parts[i:]) parent = package_dir.get("") or "" return os.path.join(root_dir, parent.split("/"), parts) def construct_package_dir(packages: list[str], package_path: StrPath) -> dict[str, str]: parent_pkgs = remove_nested_packages(packages) prefix = Path(package_path).parts return {pkg: "/".join([prefix, *pkg.split(".")]) for pkg in parent_pkgs}	20.76 KB	2026-01-20 12:58
📄 dist.py from __future__ import annotations import functools import io import itertools import numbers import os import re import sys from collections.abc import Iterable, Iterator, MutableMapping, Sequence from glob import glob from pathlib import Path from typing import TYPE_CHECKING, Any, Union from more_itertools import partition, unique_everseen from packaging.markers import InvalidMarker, Marker from packaging.specifiers import InvalidSpecifier, SpecifierSet from packaging.version import Version from . import ( _entry_points, _reqs, _static, command as _, # noqa: F401 # imported for side-effects ) from ._importlib import metadata from ._normalization import _canonicalize_license_expression from ._path import StrPath from ._reqs import _StrOrIter from .config import pyprojecttoml, setupcfg from .discovery import ConfigDiscovery from .errors import InvalidConfigError from .monkey import get_unpatched from .warnings import InformationOnly, SetuptoolsDeprecationWarning import distutils.cmd import distutils.command import distutils.core import distutils.dist import distutils.log from distutils.debug import DEBUG from distutils.errors import DistutilsOptionError, DistutilsSetupError from distutils.fancy_getopt import translate_longopt from distutils.util import strtobool if TYPE_CHECKING: from typing_extensions import TypeAlias __all__ = ['Distribution'] _sequence = tuple, list """ :meta private: Supported iterable types that are known to be: - ordered (which `set` isn't) - not match a str (which `Sequence[str]` does) - not imply a nested type (like `dict`) for use with `isinstance`. """ _Sequence: TypeAlias = Union[tuple[str, ...], list[str]] # This is how stringifying _Sequence would look in Python 3.10 _sequence_type_repr = "tuple[str, ...] \| list[str]" _OrderedStrSequence: TypeAlias = Union[str, dict[str, Any], Sequence[str]] """ :meta private: Avoid single-use iterable. Disallow sets. A poor approximation of an OrderedSequence (dict doesn't match a Sequence). """ def __getattr__(name: str) -> Any: # pragma: no cover if name == "sequence": SetuptoolsDeprecationWarning.emit( "`setuptools.dist.sequence` is an internal implementation detail.", "Please define your own `sequence = tuple, list` instead.", due_date=(2025, 8, 28), # Originally added on 2024-08-27 ) return _sequence raise AttributeError(f"module {__name__!r} has no attribute {name!r}") def check_importable(dist, attr, value): try: ep = metadata.EntryPoint(value=value, name=None, group=None) assert not ep.extras except (TypeError, ValueError, AttributeError, AssertionError) as e: raise DistutilsSetupError( f"{attr!r} must be importable 'module:attrs' string (got {value!r})" ) from e def assert_string_list(dist, attr: str, value: _Sequence) -> None: """Verify that value is a string list""" try: # verify that value is a list or tuple to exclude unordered # or single-use iterables assert isinstance(value, _sequence) # verify that elements of value are strings assert ''.join(value) != value except (TypeError, ValueError, AttributeError, AssertionError) as e: raise DistutilsSetupError( f"{attr!r} must be of type <{_sequence_type_repr}> (got {value!r})" ) from e def check_nsp(dist, attr, value): """Verify that namespace packages are valid""" ns_packages = value assert_string_list(dist, attr, ns_packages) for nsp in ns_packages: if not dist.has_contents_for(nsp): raise DistutilsSetupError( f"Distribution contains no modules or packages for namespace package {nsp!r}" ) parent, _sep, _child = nsp.rpartition('.') if parent and parent not in ns_packages: distutils.log.warn( "WARNING: %r is declared as a package namespace, but %r" " is not: please correct this in setup.py", nsp, parent, ) SetuptoolsDeprecationWarning.emit( "The namespace_packages parameter is deprecated.", "Please replace its usage with implicit namespaces (PEP 420).", see_docs="references/keywords.html#keyword-namespace-packages", # TODO: define due_date, it may break old packages that are no longer # maintained (e.g. sphinxcontrib extensions) when installed from source. # Warning officially introduced in May 2022, however the deprecation # was mentioned much earlier in the docs (May 2020, see #2149). ) def check_extras(dist, attr, value): """Verify that extras_require mapping is valid""" try: list(itertools.starmap(_check_extra, value.items())) except (TypeError, ValueError, AttributeError) as e: raise DistutilsSetupError( "'extras_require' must be a dictionary whose values are " "strings or lists of strings containing valid project/version " "requirement specifiers." ) from e def _check_extra(extra, reqs): _name, _sep, marker = extra.partition(':') try: _check_marker(marker) except InvalidMarker: msg = f"Invalid environment marker: {marker} ({extra!r})" raise DistutilsSetupError(msg) from None list(_reqs.parse(reqs)) def _check_marker(marker): if not marker: return m = Marker(marker) m.evaluate() def assert_bool(dist, attr, value): """Verify that value is True, False, 0, or 1""" if bool(value) != value: raise DistutilsSetupError(f"{attr!r} must be a boolean value (got {value!r})") def invalid_unless_false(dist, attr, value): if not value: DistDeprecationWarning.emit(f"{attr} is ignored.") # TODO: should there be a `due_date` here? return raise DistutilsSetupError(f"{attr} is invalid.") def check_requirements(dist, attr: str, value: _OrderedStrSequence) -> None: """Verify that install_requires is a valid requirements list""" try: list(_reqs.parse(value)) if isinstance(value, set): raise TypeError("Unordered types are not allowed") except (TypeError, ValueError) as error: msg = ( f"{attr!r} must be a string or iterable of strings " f"containing valid project/version requirement specifiers; {error}" ) raise DistutilsSetupError(msg) from error def check_specifier(dist, attr, value): """Verify that value is a valid version specifier""" try: SpecifierSet(value) except (InvalidSpecifier, AttributeError) as error: msg = f"{attr!r} must be a string containing valid version specifiers; {error}" raise DistutilsSetupError(msg) from error def check_entry_points(dist, attr, value): """Verify that entry_points map is parseable""" try: _entry_points.load(value) except Exception as e: raise DistutilsSetupError(e) from e def check_package_data(dist, attr, value): """Verify that value is a dictionary of package names to glob lists""" if not isinstance(value, dict): raise DistutilsSetupError( f"{attr!r} must be a dictionary mapping package names to lists of " "string wildcard patterns" ) for k, v in value.items(): if not isinstance(k, str): raise DistutilsSetupError( f"keys of {attr!r} dict must be strings (got {k!r})" ) assert_string_list(dist, f'values of {attr!r} dict', v) def check_packages(dist, attr, value): for pkgname in value: if not re.match(r'\w+(\.\w+)', pkgname): distutils.log.warn( "WARNING: %r not a valid package name; please use only " ".-separated package names in setup.py", pkgname, ) if TYPE_CHECKING: # Work around a mypy issue where type[T] can't be used as a base: https://github.com/python/mypy/issues/10962 from distutils.core import Distribution as _Distribution else: _Distribution = get_unpatched(distutils.core.Distribution) class Distribution(_Distribution): """Distribution with support for tests and package data This is an enhanced version of 'distutils.dist.Distribution' that effectively adds the following new optional keyword arguments to 'setup()': 'install_requires' -- a string or sequence of strings specifying project versions that the distribution requires when installed, in the format used by 'pkg_resources.require()'. They will be installed automatically when the package is installed. If you wish to use packages that are not available in PyPI, or want to give your users an alternate download location, you can add a 'find_links' option to the '[easy_install]' section of your project's 'setup.cfg' file, and then setuptools will scan the listed web pages for links that satisfy the requirements. 'extras_require' -- a dictionary mapping names of optional "extras" to the additional requirement(s) that using those extras incurs. For example, this:: extras_require = dict(reST = ["docutils>=0.3", "reSTedit"]) indicates that the distribution can optionally provide an extra capability called "reST", but it can only be used if docutils and reSTedit are installed. If the user installs your package using EasyInstall and requests one of your extras, the corresponding additional requirements will be installed if needed. 'package_data' -- a dictionary mapping package names to lists of filenames or globs to use to find data files contained in the named packages. If the dictionary has filenames or globs listed under '""' (the empty string), those names will be searched for in every package, in addition to any names for the specific package. Data files found using these names/globs will be installed along with the package, in the same location as the package. Note that globs are allowed to reference the contents of non-package subdirectories, as long as you use '/' as a path separator. (Globs are automatically converted to platform-specific paths at runtime.) In addition to these new keywords, this class also has several new methods for manipulating the distribution's contents. For example, the 'include()' and 'exclude()' methods can be thought of as in-place add and subtract commands that add or remove packages, modules, extensions, and so on from the distribution. """ _DISTUTILS_UNSUPPORTED_METADATA = { 'long_description_content_type': lambda: None, 'project_urls': dict, 'provides_extras': dict, # behaves like an ordered set 'license_expression': lambda: None, 'license_file': lambda: None, 'license_files': lambda: None, 'install_requires': list, 'extras_require': dict, } # Used by build_py, editable_wheel and install_lib commands for legacy namespaces namespace_packages: list[str] #: :meta private: DEPRECATED # Any: Dynamic assignment results in Incompatible types in assignment def __init__(self, attrs: MutableMapping[str, Any] \| None = None) -> None: have_package_data = hasattr(self, "package_data") if not have_package_data: self.package_data: dict[str, list[str]] = {} attrs = attrs or {} self.dist_files: list[tuple[str, str, str]] = [] self.include_package_data: bool \| None = None self.exclude_package_data: dict[str, list[str]] \| None = None # Filter-out setuptools' specific options. self.src_root: str \| None = attrs.pop("src_root", None) self.dependency_links: list[str] = attrs.pop('dependency_links', []) self.setup_requires: list[str] = attrs.pop('setup_requires', []) for ep in metadata.entry_points(group='distutils.setup_keywords'): vars(self).setdefault(ep.name, None) metadata_only = set(self._DISTUTILS_UNSUPPORTED_METADATA) metadata_only -= {"install_requires", "extras_require"} dist_attrs = {k: v for k, v in attrs.items() if k not in metadata_only} _Distribution.__init__(self, dist_attrs) # Private API (setuptools-use only, not restricted to Distribution) # Stores files that are referenced by the configuration and need to be in the # sdist (e.g. `version = file: VERSION.txt`) self._referenced_files = set[str]() self.set_defaults = ConfigDiscovery(self) self._set_metadata_defaults(attrs) self.metadata.version = self._normalize_version(self.metadata.version) self._finalize_requires() def _validate_metadata(self): required = {"name"} provided = { key for key in vars(self.metadata) if getattr(self.metadata, key, None) is not None } missing = required - provided if missing: msg = f"Required package metadata is missing: {missing}" raise DistutilsSetupError(msg) def _set_metadata_defaults(self, attrs): """ Fill-in missing metadata fields not supported by distutils. Some fields may have been set by other tools (e.g. pbr). Those fields (vars(self.metadata)) take precedence to supplied attrs. """ for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items(): vars(self.metadata).setdefault(option, attrs.get(option, default())) @staticmethod def _normalize_version(version): from . import sic if isinstance(version, numbers.Number): # Some people apparently take "version number" too literally :) version = str(version) elif isinstance(version, sic) or version is None: return version normalized = str(Version(version)) if version != normalized: InformationOnly.emit(f"Normalizing '{version}' to '{normalized}'") return normalized return version def _finalize_requires(self): """ Set `metadata.python_requires` and fix environment markers in `install_requires` and `extras_require`. """ if getattr(self, 'python_requires', None): self.metadata.python_requires = self.python_requires self._normalize_requires() self.metadata.install_requires = self.install_requires self.metadata.extras_require = self.extras_require if self.extras_require: for extra in self.extras_require.keys(): # Setuptools allows a weird "<name>:<env markers> syntax for extras extra = extra.split(':')[0] if extra: self.metadata.provides_extras.setdefault(extra) def _normalize_requires(self): """Make sure requirement-related attributes exist and are normalized""" install_requires = getattr(self, "install_requires", None) or [] extras_require = getattr(self, "extras_require", None) or {} # Preserve the "static"-ness of values parsed from config files list_ = _static.List if _static.is_static(install_requires) else list self.install_requires = list_(map(str, _reqs.parse(install_requires))) dict_ = _static.Dict if _static.is_static(extras_require) else dict self.extras_require = dict_( (k, list(map(str, _reqs.parse(v or [])))) for k, v in extras_require.items() ) def _finalize_license_expression(self) -> None: """ Normalize license and license_expression. >>> dist = Distribution({"license_expression": _static.Str("mit aNd gpl-3.0-OR-later")}) >>> _static.is_static(dist.metadata.license_expression) True >>> dist._finalize_license_expression() >>> _static.is_static(dist.metadata.license_expression) # preserve "static-ness" True >>> print(dist.metadata.license_expression) MIT AND GPL-3.0-or-later """ classifiers = self.metadata.get_classifiers() license_classifiers = [cl for cl in classifiers if cl.startswith("License :: ")] license_expr = self.metadata.license_expression if license_expr: str_ = _static.Str if _static.is_static(license_expr) else str normalized = str_(_canonicalize_license_expression(license_expr)) if license_expr != normalized: InformationOnly.emit(f"Normalizing '{license_expr}' to '{normalized}'") self.metadata.license_expression = normalized if license_classifiers: raise InvalidConfigError( "License classifiers have been superseded by license expressions " "(see https://peps.python.org/pep-0639/). Please remove:\n\n" + "\n".join(license_classifiers), ) elif license_classifiers: pypa_guides = "guides/writing-pyproject-toml/#license" SetuptoolsDeprecationWarning.emit( "License classifiers are deprecated.", "Please consider removing the following classifiers in favor of a " "SPDX license expression:\n\n" + "\n".join(license_classifiers), see_url=f"https://packaging.python.org/en/latest/{pypa_guides}", # Warning introduced on 2025-02-17 # TODO: Should we add a due date? It may affect old/unmaintained # packages in the ecosystem and cause problems... ) def _finalize_license_files(self) -> None: """Compute names of all license files which should be included.""" license_files: list[str] \| None = self.metadata.license_files patterns = license_files or [] license_file: str \| None = self.metadata.license_file if license_file and license_file not in patterns: patterns.append(license_file) if license_files is None and license_file is None: # Default patterns match the ones wheel uses # See https://wheel.readthedocs.io/en/stable/user_guide.html # -> 'Including license files in the generated wheel file' patterns = ['LICEN[CS]E', 'COPYING', 'NOTICE', 'AUTHORS'] files = self._expand_patterns(patterns, enforce_match=False) else: # Patterns explicitly given by the user files = self._expand_patterns(patterns, enforce_match=True) self.metadata.license_files = list(unique_everseen(files)) @classmethod def _expand_patterns( cls, patterns: list[str], enforce_match: bool = True ) -> Iterator[str]: """ >>> getfixture('sample_project_cwd') >>> list(Distribution._expand_patterns(['LICENSE.txt'])) ['LICENSE.txt'] >>> list(Distribution._expand_patterns(['pyproject.toml', 'LIC'])) ['pyproject.toml', 'LICENSE.txt'] >>> list(Distribution._expand_patterns(['src/*/.dat'])) ['src/sample/package_data.dat'] """ return ( path.replace(os.sep, "/") for pattern in patterns for path in sorted(cls._find_pattern(pattern, enforce_match)) if not path.endswith('~') and os.path.isfile(path) ) @staticmethod def _find_pattern(pattern: str, enforce_match: bool = True) -> list[str]: r""" >>> getfixture('sample_project_cwd') >>> Distribution._find_pattern("LICENSE.txt") ['LICENSE.txt'] >>> Distribution._find_pattern("/LICENSE.MIT") Traceback (most recent call last): ... setuptools.errors.InvalidConfigError: Pattern '/LICENSE.MIT' should be relative... >>> Distribution._find_pattern("../LICENSE.MIT") Traceback (most recent call last): ... setuptools.warnings.SetuptoolsDeprecationWarning: ...Pattern '../LICENSE.MIT' cannot contain '..'... >>> Distribution._find_pattern("LICEN{CSE") Traceback (most recent call last): ... setuptools.warnings.SetuptoolsDeprecationWarning: ...Pattern 'LICEN{CSE' contains invalid characters... """ pypa_guides = "specifications/glob-patterns/" if ".." in pattern: SetuptoolsDeprecationWarning.emit( f"Pattern {pattern!r} cannot contain '..'", """ Please ensure the files specified are contained by the root of the Python package (normally marked by `pyproject.toml`). """, see_url=f"https://packaging.python.org/en/latest/{pypa_guides}", due_date=(2026, 3, 20), # Introduced in 2025-03-20 # Replace with InvalidConfigError after deprecation ) if pattern.startswith((os.sep, "/")) or ":\\" in pattern: raise InvalidConfigError( f"Pattern {pattern!r} should be relative and must not start with '/'" ) if re.match(r'^[\w\-\.\/\\?\[\]]+$', pattern) is None: SetuptoolsDeprecationWarning.emit( "Please provide a valid glob pattern.", "Pattern {pattern!r} contains invalid characters.", pattern=pattern, see_url=f"https://packaging.python.org/en/latest/{pypa_guides}", due_date=(2026, 3, 20), # Introduced in 2025-02-20 ) found = glob(pattern, recursive=True) if enforce_match and not found: SetuptoolsDeprecationWarning.emit( "Cannot find any files for the given pattern.", "Pattern {pattern!r} did not match any files.", pattern=pattern, due_date=(2026, 3, 20), # Introduced in 2025-02-20 # PEP 639 requires us to error, but as a transition period # we will only issue a warning to give people time to prepare. # After the transition, this should raise an InvalidConfigError. ) return found # FIXME: 'Distribution._parse_config_files' is too complex (14) def _parse_config_files(self, filenames=None): # noqa: C901 """ Adapted from distutils.dist.Distribution.parse_config_files, this method provides the same functionality in subtly-improved ways. """ from configparser import ConfigParser # Ignore install directory options if we have a venv ignore_options = ( [] if sys.prefix == sys.base_prefix else [ 'install-base', 'install-platbase', 'install-lib', 'install-platlib', 'install-purelib', 'install-headers', 'install-scripts', 'install-data', 'prefix', 'exec-prefix', 'home', 'user', 'root', ] ) ignore_options = frozenset(ignore_options) if filenames is None: filenames = self.find_config_files() if DEBUG: self.announce("Distribution.parse_config_files():") parser = ConfigParser() parser.optionxform = str for filename in filenames: with open(filename, encoding='utf-8') as reader: if DEBUG: self.announce(" reading {filename}".format(locals())) parser.read_file(reader) for section in parser.sections(): options = parser.options(section) opt_dict = self.get_option_dict(section) for opt in options: if opt == '__name__' or opt in ignore_options: continue val = parser.get(section, opt) opt = self._enforce_underscore(opt, section) opt = self._enforce_option_lowercase(opt, section) opt_dict[opt] = (filename, val) # Make the ConfigParser forget everything (so we retain # the original filenames that options come from) parser.__init__() if 'global' not in self.command_options: return # If there was a "global" section in the config file, use it # to set Distribution options. for opt, (src, val) in self.command_options['global'].items(): alias = self.negative_opt.get(opt) if alias: val = not strtobool(val) elif opt in ('verbose', 'dry_run'): # ugh! val = strtobool(val) try: setattr(self, alias or opt, val) except ValueError as e: raise DistutilsOptionError(e) from e def _enforce_underscore(self, opt: str, section: str) -> str: if "-" not in opt or self._skip_setupcfg_normalization(section): return opt underscore_opt = opt.replace('-', '_') affected = f"(Affected: {self.metadata.name})." if self.metadata.name else "" SetuptoolsDeprecationWarning.emit( f"Invalid dash-separated key {opt!r} in {section!r} (setup.cfg), " f"please use the underscore name {underscore_opt!r} instead.", f""" Usage of dash-separated {opt!r} will not be supported in future versions. Please use the underscore name {underscore_opt!r} instead. {affected} """, see_docs="userguide/declarative_config.html", due_date=(2026, 3, 3), # Warning initially introduced in 3 Mar 2021 ) return underscore_opt def _enforce_option_lowercase(self, opt: str, section: str) -> str: if opt.islower() or self._skip_setupcfg_normalization(section): return opt lowercase_opt = opt.lower() affected = f"(Affected: {self.metadata.name})." if self.metadata.name else "" SetuptoolsDeprecationWarning.emit( f"Invalid uppercase key {opt!r} in {section!r} (setup.cfg), " f"please use lowercase {lowercase_opt!r} instead.", f""" Usage of uppercase key {opt!r} in {section!r} will not be supported in future versions. Please use lowercase {lowercase_opt!r} instead. {affected} """, see_docs="userguide/declarative_config.html", due_date=(2026, 3, 3), # Warning initially introduced in 6 Mar 2021 ) return lowercase_opt def _skip_setupcfg_normalization(self, section: str) -> bool: skip = ( 'options.extras_require', 'options.data_files', 'options.entry_points', 'options.package_data', 'options.exclude_package_data', ) return section in skip or not self._is_setuptools_section(section) def _is_setuptools_section(self, section: str) -> bool: return ( section == "metadata" or section.startswith("options") or section in _setuptools_commands() ) # FIXME: 'Distribution._set_command_options' is too complex (14) def _set_command_options(self, command_obj, option_dict=None): # noqa: C901 """ Set the options for 'command_obj' from 'option_dict'. Basically this means copying elements of a dictionary ('option_dict') to attributes of an instance ('command'). 'command_obj' must be a Command instance. If 'option_dict' is not supplied, uses the standard option dictionary for this command (from 'self.command_options'). (Adopted from distutils.dist.Distribution._set_command_options) """ command_name = command_obj.get_command_name() if option_dict is None: option_dict = self.get_option_dict(command_name) if DEBUG: self.announce(f" setting options for '{command_name}' command:") for option, (source, value) in option_dict.items(): if DEBUG: self.announce(f" {option} = {value} (from {source})") try: bool_opts = [translate_longopt(o) for o in command_obj.boolean_options] except AttributeError: bool_opts = [] try: neg_opt = command_obj.negative_opt except AttributeError: neg_opt = {} try: is_string = isinstance(value, str) if option in neg_opt and is_string: setattr(command_obj, neg_opt[option], not strtobool(value)) elif option in bool_opts and is_string: setattr(command_obj, option, strtobool(value)) elif hasattr(command_obj, option): setattr(command_obj, option, value) else: raise DistutilsOptionError( f"error in {source}: command '{command_name}' has no such option '{option}'" ) except ValueError as e: raise DistutilsOptionError(e) from e def _get_project_config_files(self, filenames: Iterable[StrPath] \| None): """Add default file and split between INI and TOML""" tomlfiles = [] standard_project_metadata = Path(self.src_root or os.curdir, "pyproject.toml") if filenames is not None: parts = partition(lambda f: Path(f).suffix == ".toml", filenames) filenames = list(parts[0]) # 1st element => predicate is False tomlfiles = list(parts[1]) # 2nd element => predicate is True elif standard_project_metadata.exists(): tomlfiles = [standard_project_metadata] return filenames, tomlfiles def parse_config_files( self, filenames: Iterable[StrPath] \| None = None, ignore_option_errors: bool = False, ) -> None: """Parses configuration files from various levels and loads configuration. """ inifiles, tomlfiles = self._get_project_config_files(filenames) self._parse_config_files(filenames=inifiles) setupcfg.parse_configuration( self, self.command_options, ignore_option_errors=ignore_option_errors ) for filename in tomlfiles: pyprojecttoml.apply_configuration(self, filename, ignore_option_errors) self._finalize_requires() self._finalize_license_expression() self._finalize_license_files() def fetch_build_eggs(self, requires: _StrOrIter) -> list[metadata.Distribution]: """Resolve pre-setup requirements""" from .installer import _fetch_build_eggs return _fetch_build_eggs(self, requires) def finalize_options(self) -> None: """ Allow plugins to apply arbitrary operations to the distribution. Each hook may optionally define a 'order' to influence the order of execution. Smaller numbers go first and the default is 0. """ group = 'setuptools.finalize_distribution_options' def by_order(hook): return getattr(hook, 'order', 0) defined = metadata.entry_points(group=group) filtered = itertools.filterfalse(self._removed, defined) loaded = map(lambda e: e.load(), filtered) for ep in sorted(loaded, key=by_order): ep(self) @staticmethod def _removed(ep): """ When removing an entry point, if metadata is loaded from an older version of Setuptools, that removed entry point will attempt to be loaded and will fail. See #2765 for more details. """ removed = { # removed 2021-09-05 '2to3_doctests', } return ep.name in removed def _finalize_setup_keywords(self): for ep in metadata.entry_points(group='distutils.setup_keywords'): value = getattr(self, ep.name, None) if value is not None: ep.load()(self, ep.name, value) def get_egg_cache_dir(self): from . import windows_support egg_cache_dir = os.path.join(os.curdir, '.eggs') if not os.path.exists(egg_cache_dir): os.mkdir(egg_cache_dir) windows_support.hide_file(egg_cache_dir) readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt') with open(readme_txt_filename, 'w', encoding="utf-8") as f: f.write( 'This directory contains eggs that were downloaded ' 'by setuptools to build, test, and run plug-ins.\n\n' ) f.write( 'This directory caches those eggs to prevent ' 'repeated downloads.\n\n' ) f.write('However, it is safe to delete this directory.\n\n') return egg_cache_dir def fetch_build_egg(self, req): """Fetch an egg needed for building""" from .installer import fetch_build_egg return fetch_build_egg(self, req) def get_command_class(self, command: str) -> type[distutils.cmd.Command]: # type: ignore[override] # Not doing complex overrides yet """Pluggable version of get_command_class()""" if command in self.cmdclass: return self.cmdclass[command] # Special case bdist_wheel so it's never loaded from "wheel" if command == 'bdist_wheel': from .command.bdist_wheel import bdist_wheel return bdist_wheel eps = metadata.entry_points(group='distutils.commands', name=command) for ep in eps: self.cmdclass[command] = cmdclass = ep.load() return cmdclass else: return _Distribution.get_command_class(self, command) def print_commands(self): for ep in metadata.entry_points(group='distutils.commands'): if ep.name not in self.cmdclass: cmdclass = ep.load() self.cmdclass[ep.name] = cmdclass return _Distribution.print_commands(self) def get_command_list(self): for ep in metadata.entry_points(group='distutils.commands'): if ep.name not in self.cmdclass: cmdclass = ep.load() self.cmdclass[ep.name] = cmdclass return _Distribution.get_command_list(self) def include(self, attrs) -> None: """Add items to distribution that are named in keyword arguments For example, 'dist.include(py_modules=["x"])' would add 'x' to the distribution's 'py_modules' attribute, if it was not already there. Currently, this method only supports inclusion for attributes that are lists or tuples. If you need to add support for adding to other attributes in this or a subclass, you can add an '_include_X' method, where 'X' is the name of the attribute. The method will be called with the value passed to 'include()'. So, 'dist.include(foo={"bar":"baz"})' will try to call 'dist._include_foo({"bar":"baz"})', which can then handle whatever special inclusion logic is needed. """ for k, v in attrs.items(): include = getattr(self, '_include_' + k, None) if include: include(v) else: self._include_misc(k, v) def exclude_package(self, package: str) -> None: """Remove packages, modules, and extensions in named package""" pfx = package + '.' if self.packages: self.packages = [ p for p in self.packages if p != package and not p.startswith(pfx) ] if self.py_modules: self.py_modules = [ p for p in self.py_modules if p != package and not p.startswith(pfx) ] if self.ext_modules: self.ext_modules = [ p for p in self.ext_modules if p.name != package and not p.name.startswith(pfx) ] def has_contents_for(self, package: str) -> bool: """Return true if 'exclude_package(package)' would do something""" pfx = package + '.' for p in self.iter_distribution_names(): if p == package or p.startswith(pfx): return True return False def _exclude_misc(self, name: str, value: _Sequence) -> None: """Handle 'exclude()' for list/tuple attrs without a special handler""" if not isinstance(value, _sequence): raise DistutilsSetupError( f"{name}: setting must be of type <{_sequence_type_repr}> (got {value!r})" ) try: old = getattr(self, name) except AttributeError as e: raise DistutilsSetupError(f"{name}: No such distribution setting") from e if old is not None and not isinstance(old, _sequence): raise DistutilsSetupError( name + ": this setting cannot be changed via include/exclude" ) elif old: setattr(self, name, [item for item in old if item not in value]) def _include_misc(self, name: str, value: _Sequence) -> None: """Handle 'include()' for list/tuple attrs without a special handler""" if not isinstance(value, _sequence): raise DistutilsSetupError( f"{name}: setting must be of type <{_sequence_type_repr}> (got {value!r})" ) try: old = getattr(self, name) except AttributeError as e: raise DistutilsSetupError(f"{name}: No such distribution setting") from e if old is None: setattr(self, name, value) elif not isinstance(old, _sequence): raise DistutilsSetupError( name + ": this setting cannot be changed via include/exclude" ) else: new = [item for item in value if item not in old] setattr(self, name, list(old) + new) def exclude(self, attrs) -> None: """Remove items from distribution that are named in keyword arguments For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from the distribution's 'py_modules' attribute. Excluding packages uses the 'exclude_package()' method, so all of the package's contained packages, modules, and extensions are also excluded. Currently, this method only supports exclusion from attributes that are lists or tuples. If you need to add support for excluding from other attributes in this or a subclass, you can add an '_exclude_X' method, where 'X' is the name of the attribute. The method will be called with the value passed to 'exclude()'. So, 'dist.exclude(foo={"bar":"baz"})' will try to call 'dist._exclude_foo({"bar":"baz"})', which can then handle whatever special exclusion logic is needed. """ for k, v in attrs.items(): exclude = getattr(self, '_exclude_' + k, None) if exclude: exclude(v) else: self._exclude_misc(k, v) def _exclude_packages(self, packages: _Sequence) -> None: if not isinstance(packages, _sequence): raise DistutilsSetupError( f"packages: setting must be of type <{_sequence_type_repr}> (got {packages!r})" ) list(map(self.exclude_package, packages)) def _parse_command_opts(self, parser, args): # Remove --with-X/--without-X options when processing command args self.global_options = self.__class__.global_options self.negative_opt = self.__class__.negative_opt # First, expand any aliases command = args[0] aliases = self.get_option_dict('aliases') while command in aliases: _src, alias = aliases[command] del aliases[command] # ensure each alias can expand only once! import shlex args[:1] = shlex.split(alias, True) command = args[0] nargs = _Distribution._parse_command_opts(self, parser, args) # Handle commands that want to consume all remaining arguments cmd_class = self.get_command_class(command) if getattr(cmd_class, 'command_consumes_arguments', None): self.get_option_dict(command)['args'] = ("command line", nargs) if nargs is not None: return [] return nargs def get_cmdline_options(self) -> dict[str, dict[str, str \| None]]: """Return a '{cmd: {opt:val}}' map of all command-line options Option names are all long, but do not include the leading '--', and contain dashes rather than underscores. If the option doesn't take an argument (e.g. '--quiet'), the 'val' is 'None'. Note that options provided by config files are intentionally excluded. """ d: dict[str, dict[str, str \| None]] = {} for cmd, opts in self.command_options.items(): val: str \| None for opt, (src, val) in opts.items(): if src != "command line": continue opt = opt.replace('_', '-') if val == 0: cmdobj = self.get_command_obj(cmd) neg_opt = self.negative_opt.copy() neg_opt.update(getattr(cmdobj, 'negative_opt', {})) for neg, pos in neg_opt.items(): if pos == opt: opt = neg val = None break else: raise AssertionError("Shouldn't be able to get here") elif val == 1: val = None d.setdefault(cmd, {})[opt] = val return d def iter_distribution_names(self): """Yield all packages, modules, and extension names in distribution""" yield from self.packages or () yield from self.py_modules or () for ext in self.ext_modules or (): if isinstance(ext, tuple): name, _buildinfo = ext else: name = ext.name if name.endswith('module'): name = name[:-6] yield name def handle_display_options(self, option_order): """If there were any non-global "display-only" options (--help-commands or the metadata display options) on the command line, display the requested info and return true; else return false. """ import sys if self.help_commands: return _Distribution.handle_display_options(self, option_order) # Stdout may be StringIO (e.g. in tests) if not isinstance(sys.stdout, io.TextIOWrapper): return _Distribution.handle_display_options(self, option_order) # Don't wrap stdout if utf-8 is already the encoding. Provides # workaround for #334. if sys.stdout.encoding.lower() in ('utf-8', 'utf8'): return _Distribution.handle_display_options(self, option_order) # Print metadata in UTF-8 no matter the platform encoding = sys.stdout.encoding sys.stdout.reconfigure(encoding='utf-8') try: return _Distribution.handle_display_options(self, option_order) finally: sys.stdout.reconfigure(encoding=encoding) def run_command(self, command) -> None: self.set_defaults() # Postpone defaults until all explicit configuration is considered # (setup() args, config files, command line and plugins) super().run_command(command) @functools.cache def _setuptools_commands() -> set[str]: try: # Use older API for importlib.metadata compatibility entry_points = metadata.distribution('setuptools').entry_points eps: Iterable[str] = (ep.name for ep in entry_points) except metadata.PackageNotFoundError: # during bootstrapping, distribution doesn't exist eps = [] return {distutils.command.__all__, *eps} class DistDeprecationWarning(SetuptoolsDeprecationWarning): """Class for warning about deprecations in dist in setuptools. Not ignored by default, unlike DeprecationWarning."""	43.83 KB	2026-01-20 12:58
📄 errors.py """setuptools.errors Provides exceptions used by setuptools modules. """ from __future__ import annotations from distutils import errors as _distutils_errors # Re-export errors from distutils to facilitate the migration to PEP632 ByteCompileError = _distutils_errors.DistutilsByteCompileError CCompilerError = _distutils_errors.CCompilerError ClassError = _distutils_errors.DistutilsClassError CompileError = _distutils_errors.CompileError ExecError = _distutils_errors.DistutilsExecError FileError = _distutils_errors.DistutilsFileError InternalError = _distutils_errors.DistutilsInternalError LibError = _distutils_errors.LibError LinkError = _distutils_errors.LinkError ModuleError = _distutils_errors.DistutilsModuleError OptionError = _distutils_errors.DistutilsOptionError PlatformError = _distutils_errors.DistutilsPlatformError PreprocessError = _distutils_errors.PreprocessError SetupError = _distutils_errors.DistutilsSetupError TemplateError = _distutils_errors.DistutilsTemplateError UnknownFileError = _distutils_errors.UnknownFileError # The root error class in the hierarchy BaseError = _distutils_errors.DistutilsError class InvalidConfigError(OptionError): # type: ignore[valid-type, misc] # distutils imports are `Any` on python 3.12+ """Error used for invalid configurations.""" class RemovedConfigError(OptionError): # type: ignore[valid-type, misc] # distutils imports are `Any` on python 3.12+ """Error used for configurations that were deprecated and removed.""" class RemovedCommandError(BaseError, RuntimeError): # type: ignore[valid-type, misc] # distutils imports are `Any` on python 3.12+ """Error used for commands that have been removed in setuptools. Since ``setuptools`` is built on ``distutils``, simply removing a command from ``setuptools`` will make the behavior fall back to ``distutils``; this error is raised if a command exists in ``distutils`` but has been actively removed in ``setuptools``. """ class PackageDiscoveryError(BaseError, RuntimeError): # type: ignore[valid-type, misc] # distutils imports are `Any` on python 3.12+ """Impossible to perform automatic discovery of packages and/or modules. The current project layout or given discovery options can lead to problems when scanning the project directory. Setuptools might also refuse to complete auto-discovery if an error prone condition is detected (e.g. when a project is organised as a flat-layout but contains multiple directories that can be taken as top-level packages inside a single distribution []_). In these situations the users are encouraged to be explicit about which packages to include or to make the discovery parameters more specific. .. [] Since multi-package distributions are uncommon it is very likely that the developers did not intend for all the directories to be packaged, and are just leaving auxiliary code in the repository top-level, such as maintenance-related scripts. """	2.95 KB	2026-01-20 12:58
📄 extension.py from __future__ import annotations import functools import re from typing import TYPE_CHECKING from setuptools._path import StrPath from .monkey import get_unpatched import distutils.core import distutils.errors import distutils.extension def _have_cython(): """ Return True if Cython can be imported. """ cython_impl = 'Cython.Distutils.build_ext' try: # from (cython_impl) import build_ext __import__(cython_impl, fromlist=['build_ext']).build_ext except Exception: return False return True # for compatibility have_pyrex = _have_cython if TYPE_CHECKING: # Work around a mypy issue where type[T] can't be used as a base: https://github.com/python/mypy/issues/10962 from distutils.core import Extension as _Extension else: _Extension = get_unpatched(distutils.core.Extension) class Extension(_Extension): """ Describes a single extension module. This means that all source files will be compiled into a single binary file ``<module path>.<suffix>`` (with ``<module path>`` derived from ``name`` and ``<suffix>`` defined by one of the values in ``importlib.machinery.EXTENSION_SUFFIXES``). In the case ``.pyx`` files are passed as ``sources and`` ``Cython`` is not installed in the build environment, ``setuptools`` may also try to look for the equivalent ``.cpp`` or ``.c`` files. :arg str name: the full name of the extension, including any packages -- ie. not a filename or pathname, but Python dotted name :arg list[str\|os.PathLike[str]] sources: list of source filenames, relative to the distribution root (where the setup script lives), in Unix form (slash-separated) for portability. Source files may be C, C++, SWIG (.i), platform-specific resource files, or whatever else is recognized by the "build_ext" command as source for a Python extension. :keyword list[str] include_dirs: list of directories to search for C/C++ header files (in Unix form for portability) :keyword list[tuple[str, str\|None]] define_macros: list of macros to define; each macro is defined using a 2-tuple: the first item corresponding to the name of the macro and the second item either a string with its value or None to define it without a particular value (equivalent of "#define FOO" in source or -DFOO on Unix C compiler command line) :keyword list[str] undef_macros: list of macros to undefine explicitly :keyword list[str] library_dirs: list of directories to search for C/C++ libraries at link time :keyword list[str] libraries: list of library names (not filenames or paths) to link against :keyword list[str] runtime_library_dirs: list of directories to search for C/C++ libraries at run time (for shared extensions, this is when the extension is loaded). Setting this will cause an exception during build on Windows platforms. :keyword list[str] extra_objects: list of extra files to link with (eg. object files not implied by 'sources', static library that must be explicitly specified, binary resource files, etc.) :keyword list[str] extra_compile_args: any extra platform- and compiler-specific information to use when compiling the source files in 'sources'. For platforms and compilers where "command line" makes sense, this is typically a list of command-line arguments, but for other platforms it could be anything. :keyword list[str] extra_link_args: any extra platform- and compiler-specific information to use when linking object files together to create the extension (or to create a new static Python interpreter). Similar interpretation as for 'extra_compile_args'. :keyword list[str] export_symbols: list of symbols to be exported from a shared extension. Not used on all platforms, and not generally necessary for Python extensions, which typically export exactly one symbol: "init" + extension_name. :keyword list[str] swig_opts: any extra options to pass to SWIG if a source file has the .i extension. :keyword list[str] depends: list of files that the extension depends on :keyword str language: extension language (i.e. "c", "c++", "objc"). Will be detected from the source extensions if not provided. :keyword bool optional: specifies that a build failure in the extension should not abort the build process, but simply not install the failing extension. :keyword bool py_limited_api: opt-in flag for the usage of :doc:`Python's limited API <python:c-api/stable>`. :raises setuptools.errors.PlatformError: if ``runtime_library_dirs`` is specified on Windows. (since v63) """ # These 4 are set and used in setuptools/command/build_ext.py # The lack of a default value and risk of `AttributeError` is purposeful # to avoid people forgetting to call finalize_options if they modify the extension list. # See example/rationale in https://github.com/pypa/setuptools/issues/4529. _full_name: str #: Private API, internal use only. _links_to_dynamic: bool #: Private API, internal use only. _needs_stub: bool #: Private API, internal use only. _file_name: str #: Private API, internal use only. def __init__( self, name: str, sources: list[StrPath], args, py_limited_api: bool = False, kw, ) -> None: # The args is needed for compatibility as calls may use positional # arguments. py_limited_api may be set only via keyword. self.py_limited_api = py_limited_api super().__init__( name, sources, # type: ignore[arg-type] # Vendored version of setuptools supports PathLike args, *kw, ) def _convert_pyx_sources_to_lang(self): """ Replace sources with .pyx extensions to sources with the target language extension. This mechanism allows language authors to supply pre-converted sources but to prefer the .pyx sources. """ if _have_cython(): # the build has Cython, so allow it to compile the .pyx files return lang = self.language or '' target_ext = '.cpp' if lang.lower() == 'c++' else '.c' sub = functools.partial(re.sub, '.pyx$', target_ext) self.sources = list(map(sub, self.sources)) class Library(Extension): """Just like a regular Extension, but built as a library instead"""	6.53 KB	2026-01-20 12:58
📄 glob.py """ Filename globbing utility. Mostly a copy of `glob` from Python 3.5. Changes include: * `yield from` and PEP3102 `` removed. Hidden files are not ignored. """ from __future__ import annotations import fnmatch import os import re from collections.abc import Iterable, Iterator from typing import TYPE_CHECKING, AnyStr, overload if TYPE_CHECKING: from _typeshed import BytesPath, StrOrBytesPath, StrPath __all__ = ["glob", "iglob", "escape"] def glob(pathname: AnyStr, recursive: bool = False) -> list[AnyStr]: """Return a list of paths matching a pathname pattern. The pattern may contain simple shell-style wildcards a la fnmatch. However, unlike fnmatch, filenames starting with a dot are special cases that are not matched by '' and '?' patterns. If recursive is true, the pattern '' will match any files and zero or more directories and subdirectories. """ return list(iglob(pathname, recursive=recursive)) def iglob(pathname: AnyStr, recursive: bool = False) -> Iterator[AnyStr]: """Return an iterator which yields the paths matching a pathname pattern. The pattern may contain simple shell-style wildcards a la fnmatch. However, unlike fnmatch, filenames starting with a dot are special cases that are not matched by '' and '?' patterns. If recursive is true, the pattern '*' will match any files and zero or more directories and subdirectories. """ it = _iglob(pathname, recursive) if recursive and _isrecursive(pathname): s = next(it) # skip empty string assert not s return it def _iglob(pathname: AnyStr, recursive: bool) -> Iterator[AnyStr]: dirname, basename = os.path.split(pathname) glob_in_dir = glob2 if recursive and _isrecursive(basename) else glob1 if not has_magic(pathname): if basename: if os.path.lexists(pathname): yield pathname else: # Patterns ending with a slash should match only directories if os.path.isdir(dirname): yield pathname return if not dirname: yield from glob_in_dir(dirname, basename) return # `os.path.split()` returns the argument itself as a dirname if it is a # drive or UNC path. Prevent an infinite recursion if a drive or UNC path # contains magic characters (i.e. r'\\?\C:'). if dirname != pathname and has_magic(dirname): dirs: Iterable[AnyStr] = _iglob(dirname, recursive) else: dirs = [dirname] if not has_magic(basename): glob_in_dir = glob0 for dirname in dirs: for name in glob_in_dir(dirname, basename): yield os.path.join(dirname, name) # These 2 helper functions non-recursively glob inside a literal directory. # They return a list of basenames. `glob1` accepts a pattern while `glob0` # takes a literal basename (so it only has to check for its existence). @overload def glob1(dirname: StrPath, pattern: str) -> list[str]: ... @overload def glob1(dirname: BytesPath, pattern: bytes) -> list[bytes]: ... def glob1(dirname: StrOrBytesPath, pattern: str \| bytes) -> list[str] \| list[bytes]: if not dirname: if isinstance(pattern, bytes): dirname = os.curdir.encode('ASCII') else: dirname = os.curdir try: names = os.listdir(dirname) except OSError: return [] # mypy false-positives: str or bytes type possibility is always kept in sync return fnmatch.filter(names, pattern) # type: ignore[type-var, return-value] def glob0(dirname, basename): if not basename: # `os.path.split()` returns an empty basename for paths ending with a # directory separator. 'qx/' should match only directories. if os.path.isdir(dirname): return [basename] else: if os.path.lexists(os.path.join(dirname, basename)): return [basename] return [] # This helper function recursively yields relative pathnames inside a literal # directory. @overload def glob2(dirname: StrPath, pattern: str) -> Iterator[str]: ... @overload def glob2(dirname: BytesPath, pattern: bytes) -> Iterator[bytes]: ... def glob2(dirname: StrOrBytesPath, pattern: str \| bytes) -> Iterator[str \| bytes]: assert _isrecursive(pattern) yield pattern[:0] yield from _rlistdir(dirname) # Recursively yields relative pathnames inside a literal directory. @overload def _rlistdir(dirname: StrPath) -> Iterator[str]: ... @overload def _rlistdir(dirname: BytesPath) -> Iterator[bytes]: ... def _rlistdir(dirname: StrOrBytesPath) -> Iterator[str \| bytes]: if not dirname: if isinstance(dirname, bytes): dirname = os.curdir.encode('ASCII') else: dirname = os.curdir try: names = os.listdir(dirname) except OSError: return for x in names: yield x # mypy false-positives: str or bytes type possibility is always kept in sync path = os.path.join(dirname, x) if dirname else x # type: ignore[arg-type] for y in _rlistdir(path): yield os.path.join(x, y) # type: ignore[arg-type] magic_check = re.compile('([?[])') magic_check_bytes = re.compile(b'([?[])') def has_magic(s: str \| bytes) -> bool: if isinstance(s, bytes): return magic_check_bytes.search(s) is not None else: return magic_check.search(s) is not None def _isrecursive(pattern: str \| bytes) -> bool: if isinstance(pattern, bytes): return pattern == b'' else: return pattern == '' def escape(pathname): """Escape all special characters.""" # Escaping is done by wrapping any of "*?[" between square brackets. # Metacharacters do not work in the drive part and shouldn't be escaped. drive, pathname = os.path.splitdrive(pathname) if isinstance(pathname, bytes): pathname = magic_check_bytes.sub(rb'[\1]', pathname) else: pathname = magic_check.sub(r'[\1]', pathname) return drive + pathname	5.92 KB	2026-01-20 12:58
📄 gui-32.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��z 2�da�da�da�c�a�dasee`�dase�a�dasea`�dase``�daseg`�da�ce`�da�ea�da�d``�da�d�a�da�df`�daRich�da��PE��L��'hd��$��0��@��p��@��6��P��`��2��2��@��0��.text�� `.rdata�� 0��@��@.data��@��(��@��.rsrc��P����@��@.reloc��`��,��@��B��C@��U��}�u�@@��t j�P�0@��]��U��EPj��u�u��p�0��1@��]��U��j�u�u��]��U��S�]VW�K��C��u�+�j�]��P�x0@��ȃ��M�3��"�q3ɉM��~S�U�<\uG�&<"u ��~Wj\V��M��U�3��\F�3��A�F�M�;�\|�~Wj\V�t��E�_f�"�^[��]��U��@@�3ŉE��E��E��h��Pj��0@�j�h��jj�jh��P��0@�j�h��QP�0@��Q�A��u�+ʍ��;�v�8.t��H;�w퍍��If��A�I��u��1@��1@��A��1@�W�A��j�P��u2��Ph�1@�j��0@��P��G_�M�3��]�Vh��PW��W��H@;�s��t �� t�� u�j��h�1@�P�1@��t&��1@��~�1@��1@�fօ��΍QD��A��u�S+�jQ�x0@��3ۉ��Q��1@��t�FFP�1@��u��F��P�1@��t��tm��\uC�ƀ�"u0�Ã��u 3��3��9��EȈ��tSj\W��3ۊ��o��G�g��tSj\W��3ۋ��@��G��<�t-�P�1@��t�FFP�1@��u�>��;�Ǌ��t��@��/u�\��u�5h0@��P��P��P��PW�փ��\��P��P��P��P��P�֍��Q�A��u�+ʊ� �� Ӏ�\u�Q�3��\��\tf��;�r ��H�8\u�j�W��P��P��P�l0@��=x0@�jh��׋��h��PV��1@��(�,�x0@�jh��h��WV�1@��=x0@��u/�3h�1@�j��0@��P�r��F[^_�M�3��Q��]Ë��j� ��A�P�׋�V��~��{��9��~��4��R��C��;�\|勵��P�3��9��~/��4��C��;�\|勵��}��t@��V��0@��Vh�1@�j��0@��P�l��[^_�M�3��I��]Ë΍Q�A��u��+ʺ��y;�~0�󐋅��Y@��A��u�+�GB�;�\|ߋ��x0@�jW��Vh�1@�P��N��F��u��+�;�~O@�ff��4��h�1@�P�d��QD��A��u�+�FG�;�\|�W�ǅ��jh@��ǅ��D��f��f��f��f��f��f��f��f��0@��P��Pj�j�j�jj�j��j��0@��u,hP1@�j��0@��P��3�[^_�M�3��]Ë��j��@@��0@��P��0@��u,hl1@�j��0@��P�v��3�[^_�M�3��V��]ËM��3�[^_�?��]��U��EPj��uj��u��p��Q��0@��H�]�; @@�u��y��Vj�v��V��P��D��j�0��^��ts��l��h"@��n��P�>��YY��uQ��c��th�@��Y�)��$��P�G��Y��t� ��T��u�j�-��3��P��Y�jh�5@��/��j��Y��P��2ۈ]�e��Eܡ<C@�3�A;��/��uI� <C@�h<1@�h01@�� YY��t�E��h,1@�h$1@��[ ��YY�<C@��و]�u��Y�i��3�9>tV�9��Y��t�6WjW��1@��G��9>tV��Y��t�6�$ ��Y�� 0� ��WV�0�q��.��tk��u�� j�j�{��YY�E��5�M��E�QP�{ ��YYËe��t2�}��u� ��E��E�M�d� ��Y_^[��j��V�j ��u��h ��t��U��j��D0@��u�H0@�h ��@0@�P�<0@�]�U��$��j�80@��tjY�)� A@�� A@��A@��A@��5A@��=A@�f�8A@�f� ,A@�f�A@�f�A@�f�%�A@�f�-�@@��0A@��E��$A@��E�(A@��E�4A@��p@@��(A@��,@@�� @@� ��$@@��0@@��jXk��ǀ4@@��jXk�� @@��L�jX�� @@��L�h2@��U��EV�H<��A�Q��Ak�(�;�t�M;Jr �BB;�r��(;�u�3�^]Ë��V��t d��@C@��P�;�t3��u�2�^ð^�U��}�u�DC@��v��r��u2�]��e��u j��Z��Y��]�U��=EC@��t�]�V�u��t��ub��t&��u"hHC@��Y��uhTC@��y��Y��t+2��0�� HC@�� LC@�� PC@�� TC@�� XC@�� \C@��EC@��^]�j�/��jh�6@��K��e��MZ��f9��@�u]�<�@��@�PE��uL��f9��@�u>�E��@�+�PQ�\|��YY��t'�x$�\|!�E��E��3Ɂ8��Ëe��E��2��M�d� ��Y_^[��U��t�}�u 3��@C@��]�U��=DC@��t�}�u�u��u��YY�]�U��=HC@��uu�T��hHC@��B��Y��Y��#E]�U��u��Y��H]�U��e��E�e��P�(0@��E�3E�E��,0@�1E��00@�1E��E�P�40@��E�M�3E�3E�3��Ë @@�VW�N�@��;�t��u&��;�u�O�@��u G��ȉ @@��_� �@@�^�3��3�@ø�@��h`C@��$0@�ð�h��h��j��g��u�j�?��hC@��H�$�H��H��H�3�9@@��ø�C@�ø�C@��U��$��Sj�80@��t�M�)j��$��j�P�F��\|��x��f��f��f��t��f��p��f��l��f��h��E��E��ǅ��@�jP��E�j�P��E��E��@�E��E�� 0@�j��X��ۍE��E��ۉE��D0@��E�P�H0@��u��uj��Y[��e��j��L0@��t3�MZ��f9u)�H<ȁ9PE��u��f9Au�ytv��2��h�!@��D0@��U��VW�}�7�>csm�u%�~u�F= �t=!�t="�t=�@�t_3�^]��0�w��0�\��̃%pC@��SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[�SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[��h�"@�d�5��D$�l$�l$+�SVW�@@�1E�3�P�e�u��E��E��E��E�d��U��V�u�6��u��u�uVh2@�h@@��^]�U��%tC@��$� @@�j �80@��e��3�SVW3ɍ}�S��[��w�O3ɉW�E܋}�E�Genu�E�5ineI�E��E�5ntel�E�3�@S��[��]܉�E�E�ǉs�K�SuC�E�%�?�=��t#=`�t=p�t=P�t=`�t=p�u�=xC@��=xC@��=xC@��M�jX�M�9E�\|03�S��[��]܉�s�K�M��S�]��t��=xC@��]�@@��tC@��@@��tC@��@@��ty��tq3�ЉE�U�E�M�j^#�;�uW�@@��tC@��@@�� t;�� tC@��@@��#�;�u�E��M�#�;�u � @@�@�5tC@�_^[3��3�9@@��%T0@��%X0@��%`0@��%\0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%1@��%�0@��%�0@��%�0@��%�0@��%t0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@�U��Q�=tC@�\|f�}��t �}��uT�]��E��?��t?��u��é��t��u��é��u��é ��u��ø��ËE��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��@��@��@@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.pyw�Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s�� @@�p@@��@@��3@��1@��3@�� 1@��'hd�� l��`3��`��"��3��,��H3��"��(#��#��$��$��$��$��c$��k$��@��"��N%��x��.text$mn��0��.idata$5��1��.00cfg��$1��.CRT$XCA��(1��.CRT$XCAA��,1��.CRT$XCZ��01��.CRT$XIA��41��.CRT$XIAA��81��.CRT$XIAC��<1��.CRT$XIZ��@1��.CRT$XPA��D1��.CRT$XPZ��H1��.CRT$XTA��L1��.CRT$XTZ��P1��.rdata��3��.rdata$sxdata��3��\��.rdata$voltmd��`3��l��.rdata$zzzdbg��5��.rtc$IAA��5��.rtc$IZZ��5��.rtc$TAA��5��.rtc$TZZ��5��<��.xdata$x��6��.idata$2��6��.idata$3��6��.idata$4��8��.idata$6��@��.data��@��x��.bss��P��`��.rsrc$01��`P��.rsrc$02��,@�@@��N@�a@��6��8��0��L7��,9��T0��l7��;��t0��`7��;��h0��7��;��0��7��<��0��8��4<��1��7��V<��0��x7��v<��0��7��<��0��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��CreateFileA�dGetFinalPathNameByHandleA��WaitForSingleObject�QGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��H�memset��__current_exception��__current_exception_context�5�_except_handler4_common�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�B�_seh_filter_exe�D�_set_app_type�.�__setusermatherr��_configure_narrow_argv��5�_initialize_narrow_environment���_get_initial_narrow_environment�8�_initterm�9�_initterm_e�X�exit��%�_exit�T�_set_fmode��_cexit��_c_exit�?�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��6�_initialize_onexit_table��>�_register_onexit_function��_crt_atexit��_controlfp_s��j�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll��UnhandledExceptionFilter��SetUnhandledExceptionFilter�,GetCurrentProcess��TerminateProcess��IsProcessorFeaturePresent�mQueryPerformanceCounter�-GetCurrentProcessId�1GetCurrentThreadId��GetSystemTimeAsFileTime��InitializeSListHead��IsDebuggerPresent��GetModuleHandleW��DN�@��0�� H��`P��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��00'0[0�0J1u1�1�1�12 222:2�2�2�2�2�2�2+3>3g3&494s4M5S5w5�5�5�5�5�5�6�6�6>7I7�7�7(8P8Y8a8�8�8�8�8�8!949x9�9:3:H:M:R:s:x:�:�:�;�;�;�;�;�;�;�;�;�;�;�;�<<<<<#<+<3<;<G<P<U<[<e<o<<�<�<�<=4=g=�=�=�=�=�=�=�=�=�=�=>>> >>�>�>�>�>?'?0?=?S?�?�?�?�?�?� ��000%0�011;1z1�1�1�1�1�1222A2^2�2�2�2�2�2u3~3�3�3�3�3�3�3�3+444=4K4T4v4}4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�455555 5&5,52585>5D5J5T5��0��(��1(1418122L2P2X2�2�2�5�566��	11.5 KB	2026-01-20 12:58
📄 gui-64.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��b�c�1�c�1�c�1�61�c�1�0�c�1X1�c�1�0�c�1�0�c�1�0�c�1��0�c�1�c�1�c�1��0�c�1�Z1�c�1��0�c�1Rich�c�1��PE��d��'hd��"�$��"��0��@��`��:��p��`��0��5��3��@��0��P��.text�� `.rdata��,��0��@��@.data��H��P��0��@��.pdata��`��2��@��@.rsrc��p��4��@��@.reloc��0��6��@��B��H�)F��H��(��u� "@��t3� ��H��(��H�T$L�D$L�L$ SVWH��0H��H�t$`H��E3�H�t$ L��H��H��!��H��0_^[��A��5��H�\$H�l$H�t$H�\|$ ATAVAWH�� H��L��H��D��H��<�u��, ��3�L��A�?L��3�H��3!��t�KH��"!��u��3H��@��ta@�� !��t��tO@��\u��@��"u�׃�u 3��3��E��tL�ǲ\I��L�3�@��t�A�6I��딅�tL�ǲ\I��L�3�A��I��Ic�AA�M�t�@��t,��y ��tD��KH��c ��u�;��8��H�\$@I��H�l$HH�t$PH�\|$XH�� A_A^A\��H�\$H�l$H�t$H�\|$ AVH�� H��H��H�ǀ<9�u��?��Hc�H��3�Hc�L��"H�X��~X�<\u��&<"u ��~��\D��H�� H�3��\H��3��H�ƈH��H��u��~��\D��H��H�H�l$8I��H�t$@H�\|$Hf�"�H�\$0H�� A^�@UVWATH��$��H��H��H�=��H3�H�� D�D$dD��H�T$xA��L$`H�U3��3�H�MH�t$0E3��D$(��D$ ��D�F��E3�H�UH��A��H�MH��H��@84u�H�MH�H�MH;�v�8.t@�0H�MH��H;�w�H�M@�0H��f�@8qH�Iu��~��3ҋ~��AH�M�X��u$�H�.��H��L�EH�X��S��G��H��$��H��L��$8��A��L��$0��Hc�H��Hً��H��H�ȐH��H;�s��t �� t�� u�A��@�0H��H��t)��H�T$XH��L��H�H��tL��H��/uA��\��u�H��H��L��H�D$ L��H�T$P��@8t$P��\��H��L��H�D$ L��H�T$PH�M��H��H��@8tH�@u�D��H��A��\uD�A�H�A�HE�A��\t!ff��H��H;�r@�0H�Ȁ8\u�L��H�t$ L��H�T$PH��(��8��H��H��A��H��L��2��M��u(I�A�O��L��H�F��H��A�G�W��\|$X��L��$@��A�<Lc�L�l$hI�M��I��H�D$XH��H�H�s��~#I�^��@�H��x��H�H�[H��H��u�H�EH��H�À<�u��Hc�H��N��E3�Lc�H�D$pA��"H�x��~lE3�f�B�D5<\u��(<"u!��~�ٲ\D��H��{��H�A��\H��A��B�D5I�ƈH��M;�\|�L�l$h��~�ٲ\D��H��?��H�E3�H�D$pf�"�Hc\|$`H�H��H��~%L�d$x��I��H�H��H��H;�\|�\|$d�L�6t5H�T$XI��]��M��H��H��H��f�H��A�<�u�L�d$X��I��~-A��f�K��H��D��H��<�u��I��M;�\|�Hcɺ��M��H��H��H��H��H��A�<�u�I��~F��fff��M��H��Hc�H��J��I��H��H��<�u��H��I;�\|�W�D�t$P3��E�h��W�H�E�H� [��EE��PM�M�M�M�M�M�S��H�E�E3�H�D$HE3�H�E�H��H�D$@3�L�t$8L�t$0D�t$(�D$ �� u�H��H��H�� J�E��H�M��6��H�M�H�T$P��u�H��H��H��D�t$PA��L��$@��L��$8��H��$��L��$0��H�� H3��H��H��A\_^]��H�T$L�D$L�L$ SVWH��0H��H�t$`H��L��H�t$(H��H�D$ ��L��H��H�H��H�H��0_^[��H��(M�A8H��I�� H��(��@SE�H��A��L��A��L��tA�@McP��L�Hc�L#�Ic�J�H�C�HH�C�Dt�D��L�L3�I��[��ff��H; Q5��uH��f��u�H��@SH�� D��ts�7 ��H� l ��uR��tH� ~��m��j��t�U��P��uH�� [ù��H��(�_��3�H��(�H��(�7��H��(�M��H�\$H�t$WH��0��/��6��@2�@�t$ ��؋ �9��#��uJ��9��H��H� �� t ��H�o��H� X�� 9��@�@�t$ ��H��H�8�tH��n��tE3�A�P3�H��H��H�8�tH��B��tH��T �� H�� H�� L��H�Ӌ��tU@��u� ��3ұ��t;�\|$ �u�� H�\$@H�t$HH��0_ù�� H��(��H��(�r��@SH�� H��3��H��H�Ⱥ ��H�� [H�%��H�L$H��8��t��)H� R3��H�D$8H�94��H�D$8H��H��3��H�"4��H��2��H�D$@H��3��m2�� g2��q2��Hk��H� i2��H��Hk��H� �1��H�L ��Hk�H� �1��H�L H� h��H��8��@SVWH��@H��S��H��3�E3�H�T$`H��H��t9H�d$8�H�L$hH�T$`L��H�L$0L��H�L$pH�L$(3�H�\$ ��ǃ�\|�H��@_^[��H��(��t!eH�%0��H�H�H;�t3��H� �6��u�2�H��(ð��@SH�� 6��ɻ��DÈ�6��u2��u 3��H�� [��@SH�� =\|6��ug��wj��t(��u$H� f6��uH� n6��t.2��3fo)��H��56��H�>6��>6��H�G6��6��H�� [ù��^��H��L��MZ��f9�uxHc L�H� �Hʁ9PE��u_��f9AuTL+��QH��H��AH��L��H�$I;�t�JL;�r �B�L;�rH��(��3�H��u2��z$�}2�� 2��2�H��@SH�� 3҅�t��uH�>5��H�� [�@SH�� =35��t��u�6��/��H�� [��@SH�� H�=5��H��u�B��H��H� �4��+��3҅�HD�H��H�� [��H��(��H��H��(��H�\$UH��H��0H��.��H�2��-�+��H;�utH�e�H�M�F��H�EH�E�@��H1E�<��H�MH1E�4��EH�M�H�� H3EH3E�H3�H��H#�H�3��-�+��H;�HD�H�a.��H�\$PH��H�J.��H��0]�3��̸��̸�@��H� 94��H�%��̰��H�14��H��(��H�$��H�H��(��3�9�.��H�!4��H�4��Ã%�3��H�\$UH��$@��H��ٹ��V��t��)��3�H�M�A��H�M�1��H��H��H��E3�� H��t<H�d$8�H��H��L��H�L$0L��H��H�L$(H�M�H�L$ 3�n ��H��H�L$PH��3�H��A��H��H��t��H��H�D$`�D$P��@�D$T��J ��H�D$PH�D$@H�E��H�D$H3� ��H�L$@��u��u�H��H��$��H��]��;��H��(3��H��t9�MZ��f9u/HcH<Hȁ9PE��u ��f9Au��v��2�H��(��H� ��H�%r��H�\$WH�� H�H��;csm�u�{u�S ��l�v��@�t H�\$03�H�� _��^��H�H�_�X��H��H�\$WH�� H��H�=��H�H��t�� H��H;�r�H�\$0H�� _�H�\$WH�� H��H�=��H�H��t�� H��H;�r�H�\$0H�� _�H�\$H�t$WH��3�3��D��E3�D��A��ntelA��ineID�ˋ�3�A�CE��A��Genu�$Eщ\$��L$�T$u[H� +��%�?�H����=��t(=`�t!=p�t�� w$H��H��sD��0��A��D��0��D��0��D�H�;�\|&3��$D�ۉ\$�L$�T$�� s E�D��0��d��D� a��D� L��E��sy��ss3��H�� H�H�T$ H�D$ "�:�uW�������A�� t8�� )��)��D#�D;�uH�D$ $�<�u � �)��@��)��H�\$(3�H�t$0H��_�3�9�)��%B ��%4 ��%> ��%@ ��%� ��%� ��%� ��%��%z ��%��%� ��%� ��%� ��%� ��%� ��%� ��% ��%t ��%~ ��%� ��%" ��% ��%��%@ ��%B ��%� ��%F ��%� ��%� ��%� ��%� ��ff��ff��%� ��@UH�� H��H�H�ы��H�� ]��@UH��H�3Ɂ8��]��0=��>=��Z=��p=��=��=��=��=��A��A��B��"B��@B��TB��C��B��B��B��B��B��B��hB��A��=��=��>��(>��"C��b>��n>�� @��X>�� @��?��@��@@��\@��?��@��?��?��?��\|>��?��n?��>��>��?��?��L?��2?��x@��?��@��?��>��>��>��@��0@��@��>��>��>��!�@��!�@��P'�@��p'�@��p'�@��4'�@��@��@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.pyw��Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s��PP�@��P�@��@��P�@��P2�@��`2�@��5�@��X2�@��h2�@��p2�@��x2�@��2�@��'hd�� 5��!��5��,��5��4�� "��#��%��%��>&�� v'��6��@��.text$mn��@'��6��.text$mn$00�v'��6��.text$x��0��P��.idata$5��P2��8��.00cfg��2��.CRT$XCA��2��.CRT$XCAA��2��.CRT$XCZ��2��.CRT$XIA��2��.CRT$XIAA��2��.CRT$XIAC��2��.CRT$XIZ��2��.CRT$XPA��2��.CRT$XPZ��2��.CRT$XTA��2��.CRT$XTZ��2��.rdata��5��\��.rdata$voltmd��5��.rdata$zzzdbg��`8��.rtc$IAA��h8��.rtc$IZZ��p8��.rtc$TAA��x8��.rtc$TZZ��8��.xdata��:��.idata$2��:��.idata$3��:��P��.idata$4��0=��.idata$6��P��@��.data��@P��.bss��`��.pdata��p��`��.rsrc$01��`p��.rsrc$02��Rp`0 �t �d�T�4�2��t�d �T �4�2��B��&��p`P �� !'�'��4��8��!��<��8��!��<��8��!��8��0��20 �d �4�Rp�&��v'��(��v'��2P � b��rp`0 �"��&��e ��'��e ��P�� 4 � RP�4��P�� 4� 2p�d�4�p��:��=��0��;��F>��0��;��@��1��;��@��0��0<��@��P1��<��A��1��=��>A��02��<��`A��01��<��A�� 1�� <��A��@1��0=��>=��Z=��p=��=��=��=��=��A��A��B��"B��@B��TB��C��B��B��B��B��B��B��hB��A��=��=��>��(>��"C��b>��n>�� @��X>�� @��?��@��@@��\@��?��@��?��?��?��\|>��?��n?��>��>��?��?��L?��2?��x@��?��@��?��>��>��>��@��0@��@��>��>��>��CreateFileA�kGetFinalPathNameByHandleA�WaitForSingleObject�XGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��>�memset��__C_specific_handler��__current_exception��__current_exception_context�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�@�_seh_filter_exe�B�_set_app_type� �__setusermatherr��_configure_narrow_argv��3�_initialize_narrow_environment��(�_get_initial_narrow_environment�6�_initterm�7�_initterm_e�U�exit��#�_exit�T�_set_fmode��_cexit��_c_exit�=�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��4�_initialize_onexit_table��<�_register_onexit_function��_crt_atexit�g�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll��RtlCaptureContext��RtlLookupFunctionEntry��RtlVirtualUnwind��UnhandledExceptionFilter��SetUnhandledExceptionFilter�2GetCurrentProcess��TerminateProcess��IsProcessorFeaturePresent�pQueryPerformanceCounter�3GetCurrentProcessId�7GetCurrentThreadId�� GetSystemTimeAsFileTime��InitializeSListHead��IsDebuggerPresent��GetModuleHandleW��<�memcpy��] �f��2��-�+��4��8��@��8��8��8��8��<��8��<��8��9�� 9��8�� =��8��@��09��89��<9��8��8��0��D9��0��B��8��D��x��<9��x��J��9��L��9��8��E��<9��H��<9��l ��9��l �� <9�� <9�� <9�� !��8��!��!��9��!��"��8��0"��{#��9��#��#��8��#��C$��9��D$��$��9��$��$��9��$��h&��9��P'��R'��9��p'��v'��:��v'��'��\|9��'��'��9��0�� H��`p��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��0��0��P�X�`�h�p��(�@�H�Ф��	14 KB	2026-01-20 12:58
📄 gui-arm64.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��b��1��1��1��1��1��0��1�x1��1��0��1��0��1��0��1�0��1��1��1��0��1��z1��1��0��1Rich��1��PE��d��'hd��"�$��@��`��8��p��`�� $��4��p3��@��0��.text��4�� `.rdata��0��@��@.data��P��.��@��.pdata�� `��0��@��@.rsrc��p��2��@��@.reloc��$��4��@��B��C��1��1@��c1��_��1��@�1@��c0��T�C��_� ��{��C��{A��_��0��"��@��A��T�_�{��0��"��1��1��@�1@��G�!��>�� (��_��{��5(��!@��4��@��R�?� ��R�{��_��S��{��@��@��?�{��@��SŨ�_��S��[��c��{��i�9��i��4 �8�5�� q��T�"��Q�@�i�9��i��4I�8�5IK)� �!�Q��5��i@�!��\|@��Q�?��a��&��i�9��"��4 �8�5�"��˟�q-�T��@��3��r��ɂ_��9� �j��4 �8�5 K��QU��5��{��cB��[A��Sè�_��"��R��S��[��c��k��#��{��i�9��i��4 �8�5��i@��?��@��`�9��R��R�?��4��`�8(�@��?֠��5��t�8��4h�@���?�@��4�4�rqa��T��q�T��ra��T_�q��q��~��4���R��r��B6��R��4��8��4���R��h��B6��R��8��(��(��{(��4`�9(�@��?��4��`�8��@��?֠��5h�9H��5��{��#@��kC��cB��[A��SŨ�_��S��[��c��{��i�9��i��4 �8�5˨z�� i@�!��?�X�R��R��9��q��T��Rh�9qqa��T��qa�T��q��T���R��$��B6��R��8��Rh�8��Q��8u��5��q��T���R��B6��y��{��@��cB��[A��SĨ�_�{��S��[��c��k��+��@����* �R��?��@��Rd��R��"��R��R��?��@��R �R��?��9��i��4 �8�5�� (�� )�T�� 9_��q��T�9�� H��T�9��9��j��4�8�5��R�9)� �8i(8��5��R����1a�T��@�@��R�?��@��R� �� �� �� T �9?�q$Jz$Mz!��T�9��A�B�� ?� �4�� !�(@��W�( @��(1�9�� 9�S�� @��9��)�4��R��?��qA��Tj�9 �9I��5��Y@��C��?��C�9h�5��9qq��T��Y@��C��?��9��i��4 �8�5�� �H�� 9?qq��TI��8H ��?qq��T�� T�9 ��8_qqa��T��]@��C��?��i@�!��Ҁ ��?��i@�!��Ҁ ��?��@�� ?֗��@�@��R@��?��a��!��@��R\|��@��ҺH@��i@��?��6#�� q-�T�#��x�Q��`�@��Q��5��"��q �Ts"��Q`�@��Q��5��4��@��?��@�@��R�?�� @��RG����O��!��R��=��OA��A�A�a�� R�C��a��@��?��@��R$��R��?�@�5��@�@��R�?��A ��R��3@�(�� !�� @��@��?�� @��@��S��?�@�5��@�@��R�?�� R��@��f��+@��kD��cC��[B��SA��{ƨ�_��S��{��~��@��@��@��?��q��Z�{��@��SŨ�_��#�{��h@�� ~�(ia�(��!��L�� R�{��#�_��#��{�� R���� R��S��42��!�k��5��4�� }��SH��4{��5�{��A��#�_��R��>��#�{��R�{��#�_�#�{��{��#�_��#��S��{�� R��SH�4��R�C�9i��S3��h@��q� �Th�5(��Rh�� ! �N��`��4��RB�� C��H��Rh��5��R�C�9���h@��SH�4h@��A��R��1 A� ?��?�t��h@��Sh��4`@�8��@��@��E��i��S(�4U��5#��R ��R��* ��^��S�4�C@9H��5���{¨�@��S¨�#�_��RM��RK������>��#�{��{��#�_�#�{��4�� @�(�� ?�`�TH�_�h��I�ȱ��5�;�(��R�{��#�_� ��R��#�{��)��(�@9��q�(��9��Sh��5��R��S��5��R�� R�{��#�_�#��S��{��3��h�A9��h�5��q��T��4t�5(��5(��A��4��R ��(�� %�� (��A� %�� (��Rh�9 ��R�{��S��#�_֠��R��>�#�{��I�R��h@y k��Th=@�j�(� ��RH@� k!�TH1@y-q��T��H)@y �a��I @y ��+! ��@�T @��A��T @�) �A)��T��h��R ��%@�h��6��R�� R��R��R�{¨�#�_��#��{��S1��4��5��ȿ;�{��A��#�_�#��{��@9�S)�SH��4��5�c��a�� R�{��A��#�_��#��{�� (@��a��TY�� R��q`��{��A��#�_�#�{��Z�{��#�_��#��S��{��h@��X��T��)@��c��?��@��%@��?��@� \|@�(��!@��?��@� \|@��(��-@��?��@��#@� � ��@�)��C��(� �@�?��X��h��(�� {è�S��#�_� �2��-�+��3��-�+��R�_� ��R�_��R�_��1@��_��_��#�{�� @�(��@��{��#�_��@��q��_��A��_��!��_��`�>�_��#�{��9@��?֠��@y�I�R k!�T<@� ��R �(�H@� ka�TH1@y-q�TH�@�9�q��TH�@��q��R�{��#�_��!��5@��#��S��{��@��h@� k��Th@��q!�Ti"@��(K �q)�TH�?k��T��R�{��S��#�_�Q��@�Q��>� �csm� ��@��#��S��{�� (!��3!��B�Th�@��1 A� ?��?��T�{��S��#�_��#��S��{�� (!��3!��B�Th�@��1 A� ?��?��T�{��S��#�_��C��@��R`�>�C��_��@��q��_��F@��B@��J@��N@��@��@��@��@��z@��@��@��@��@��@��@��@��@��@��@��@��r@��f@��@��@��@��@��@��@��@��@��R@��#�{��(�@��@�� {��#�_�a��#�{��@� @��?k��{��#�_�a��;��;��;��;��<��<��.<��F<��^@��t@��@��D@��@��@��@��z<��p<��<��<��@��<��<��>��<��>��=��?��>��H>��R>��\>��=��=��>��>��>��2>��?��<�� =��>��=��=��\|=��>��D=��?��,?��$?��=��=��>��:>��r=��h=��^=��"�@��@��&�@��8�@��X�@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.pyw��Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s��P�@��0Q�@��@��P�@��2�@��2�@�� 2�@��(2�@��'hd�� h��5��!��.text��.text$mn��&��d��.text$x��0��.idata$5��2�� .00cfg��02��.CRT$XCA��82��.CRT$XCAA��@2��.CRT$XCZ��H2��.CRT$XIA��P2��.CRT$XIAA��X2��.CRT$XIAC��`2��.CRT$XIZ��h2��.CRT$XPA��p2��.CRT$XPZ��x2��.CRT$XTA��2��.CRT$XTZ��2��p��.rdata��5��h��.rdata$zzzdbg��h7��.rtc$IAA��p7��.rtc$IZZ��x7��.rtc$TAA��7��.rtc$TZZ��7��8��.xdata��8��.idata$2��9��.idata$3��9��.idata$4��;��F��.idata$6��P�� .data�� P��.bss��`�� .pdata��p��`��.rsrc$01��`p��.rsrc$02��`"��Ђ�Ђ��`"��Ђ�Ђ��^0 �� Ɉ�Ȅ��@��@�@��@��B�B��/�@(�@��k�P]�@��Ђ$��h%��&��&��@��@�@��5�p��h%��\ ��'��\ �� @��@�@���@#�@��"��%�@�@��"��9��b<��0�� :��<��0��h:��6?��0��P:��V?��0��:��\|?��1��H;��?��1��;��?��1��:��?��0��:��@��0��:��"@��1��;��;��;��;��<��<��.<��F<��^@��t@��@��D@��@��@��@��z<��p<��<��<��@��<��<��>��<��>��=��?��>��H>��R>��\>��=��=��>��>��>��2>��?��<�� =��>��=��=��\|=��>��D=��?��,?��$?��*=��=��>��:>��r=��h=��^=��CreateFileA�iGetFinalPathNameByHandleA�WaitForSingleObject�VGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��=�memset��__C_specific_handler��__current_exception��__current_exception_context�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�@�_seh_filter_exe�B�_set_app_type� �__setusermatherr��_configure_narrow_argv��3�_initialize_narrow_environment��(�_get_initial_narrow_environment�6�_initterm�7�_initterm_e�U�exit��#�_exit�T�_set_fmode��_cexit��_c_exit�=�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��4�_initialize_onexit_table��<�_register_onexit_function��_crt_atexit�g�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll�kQueryPerformanceCounter�2GetCurrentProcessId�6GetCurrentThreadId��GetSystemTimeAsFileTime��InitializeSListHead��SetUnhandledExceptionFilter��GetModuleHandleW��;�memcpy��] �f��2��-�+��7�� 7��P��7��p��L8��X8��8��5��7��p��%f��i0��0��7��7��=��X��7��!��8��%��`��8��!��0��8��a��8��`8��p ��A�A� ��M�A�!��Q�AP!��%��x!��B�"��=��0#��#��8��`$��e�B�$��e�B0%��&��@8��'��8��0�� H��`p��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��0��$��(�8�P�X�X�`�ȣ�裠��	13.5 KB	2026-01-20 12:58
📄 gui.exe MZ��@�� !�L�!This program cannot be run in DOS mode. $��z 2�da�da�da�c�a�dasee`�dase�a�dasea`�dase``�daseg`�da�ce`�da�ea�da�d``�da�d�a�da�df`�daRich�da��PE��L��'hd��$��0��@��p��@��6��P��`��2��2��@��0��.text�� `.rdata�� 0��@��@.data��@��(��@��.rsrc��P����@��@.reloc��`��,��@��B��C@��U��}�u�@@��t j�P�0@��]��U��EPj��u�u��p�0��1@��]��U��j�u�u��]��U��S�]VW�K��C��u�+�j�]��P�x0@��ȃ��M�3��"�q3ɉM��~S�U�<\uG�&<"u ��~Wj\V��M��U�3��\F�3��A�F�M�;�\|�~Wj\V�t��E�_f�"�^[��]��U��@@�3ŉE��E��E��h��Pj��0@�j�h��jj�jh��P��0@�j�h��QP�0@��Q�A��u�+ʍ��;�v�8.t��H;�w퍍��If��A�I��u��1@��1@��A��1@�W�A��j�P��u2��Ph�1@�j��0@��P��G_�M�3��]�Vh��PW��W��H@;�s��t �� t�� u�j��h�1@�P�1@��t&��1@��~�1@��1@�fօ��΍QD��A��u�S+�jQ�x0@��3ۉ��Q��1@��t�FFP�1@��u��F��P�1@��t��tm��\uC�ƀ�"u0�Ã��u 3��3��9��EȈ��tSj\W��3ۊ��o��G�g��tSj\W��3ۋ��@��G��<�t-�P�1@��t�FFP�1@��u�>��;�Ǌ��t��@��/u�\��u�5h0@��P��P��P��PW�փ��\��P��P��P��P��P�֍��Q�A��u�+ʊ� �� Ӏ�\u�Q�3��\��\tf��;�r ��H�8\u�j�W��P��P��P�l0@��=x0@�jh��׋��h��PV��1@��(�,�x0@�jh��h��WV�1@��=x0@��u/�3h�1@�j��0@��P�r��F[^_�M�3��Q��]Ë��j� ��A�P�׋�V��~��{��9��~��4��R��C��;�\|勵��P�3��9��~/��4��C��;�\|勵��}��t@��V��0@��Vh�1@�j��0@��P�l��[^_�M�3��I��]Ë΍Q�A��u��+ʺ��y;�~0�󐋅��Y@��A��u�+�GB�;�\|ߋ��x0@�jW��Vh�1@�P��N��F��u��+�;�~O@�ff��4��h�1@�P�d��QD��A��u�+�FG�;�\|�W�ǅ��jh@��ǅ��D��f��f��f��f��f��f��f��f��0@��P��Pj�j�j�jj�j��j��0@��u,hP1@�j��0@��P��3�[^_�M�3��]Ë��j��@@��0@��P��0@��u,hl1@�j��0@��P�v��3�[^_�M�3��V��]ËM��3�[^_�?��]��U��EPj��uj��u��p��Q��0@��H�]�; @@�u��y��Vj�v��V��P��D��j�0��^��ts��l��h"@��n��P�>��YY��uQ��c��th�@��Y�)��$��P�G��Y��t� ��T��u�j�-��3��P��Y�jh�5@��/��j��Y��P��2ۈ]�e��Eܡ<C@�3�A;��/��uI� <C@�h<1@�h01@�� YY��t�E��h,1@�h$1@��[ ��YY�<C@��و]�u��Y�i��3�9>tV�9��Y��t�6WjW��1@��G��9>tV��Y��t�6�$ ��Y�� 0� ��WV�0�q��.��tk��u�� j�j�{��YY�E��5�M��E�QP�{ ��YYËe��t2�}��u� ��E��E�M�d� ��Y_^[��j��V�j ��u��h ��t��U��j��D0@��u�H0@�h ��@0@�P�<0@�]�U��$��j�80@��tjY�)� A@�� A@��A@��A@��5A@��=A@�f�8A@�f� ,A@�f�A@�f�A@�f�%�A@�f�-�@@��0A@��E��$A@��E�(A@��E�4A@��p@@��(A@��,@@�� @@� ��$@@��0@@��jXk��ǀ4@@��jXk�� @@��L�jX�� @@��L�h2@��U��EV�H<��A�Q��Ak�(�;�t�M;Jr �BB;�r��(;�u�3�^]Ë��V��t d��@C@��P�;�t3��u�2�^ð^�U��}�u�DC@��v��r��u2�]��e��u j��Z��Y��]�U��=EC@��t�]�V�u��t��ub��t&��u"hHC@��Y��uhTC@��y��Y��t+2��0�� HC@�� LC@�� PC@�� TC@�� XC@�� \C@��EC@��^]�j�/��jh�6@��K��e��MZ��f9��@�u]�<�@��@�PE��uL��f9��@�u>�E��@�+�PQ�\|��YY��t'�x$�\|!�E��E��3Ɂ8��Ëe��E��2��M�d� ��Y_^[��U��t�}�u 3��@C@��]�U��=DC@��t�}�u�u��u��YY�]�U��=HC@��uu�T��hHC@��B��Y��Y��#E]�U��u��Y��H]�U��e��E�e��P�(0@��E�3E�E��,0@�1E��00@�1E��E�P�40@��E�M�3E�3E�3��Ë @@�VW�N�@��;�t��u&��;�u�O�@��u G��ȉ @@��_� �@@�^�3��3�@ø�@��h`C@��$0@�ð�h��h��j��g��u�j�?��hC@��H�$�H��H��H�3�9@@��ø�C@�ø�C@��U��$��Sj�80@��t�M�)j��$��j�P�F��\|��x��f��f��f��t��f��p��f��l��f��h��E��E��ǅ��@�jP��E�j�P��E��E��@�E��E�� 0@�j��X��ۍE��E��ۉE��D0@��E�P�H0@��u��uj��Y[��e��j��L0@��t3�MZ��f9u)�H<ȁ9PE��u��f9Au�ytv��2��h�!@��D0@��U��VW�}�7�>csm�u%�~u�F= �t=!�t="�t=�@�t_3�^]��0�w��0�\��̃%pC@��SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[�SV��5@��5@�;�sW�>��t ��1@��׃�;�r�_^[��h�"@�d�5��D$�l$�l$+�SVW�@@�1E�3�P�e�u��E��E��E��E�d��U��V�u�6��u��u�uVh2@�h@@��^]�U��%tC@��$� @@�j �80@��e��3�SVW3ɍ}�S��[��w�O3ɉW�E܋}�E�Genu�E�5ineI�E��E�5ntel�E�3�@S��[��]܉�E�E�ǉs�K�SuC�E�%�?�=��t#=`�t=p�t=P�t=`�t=p�u�=xC@��=xC@��=xC@��M�jX�M�9E�\|03�S��[��]܉�s�K�M��S�]��t��=xC@��]�@@��tC@��@@��tC@��@@��ty��tq3�ЉE�U�E�M�j^#�;�uW�@@��tC@��@@�� t;�� tC@��@@��#�;�u�E��M�#�;�u � @@�@�5tC@�_^[3��3�9@@��%T0@��%X0@��%`0@��%\0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%1@��%�0@��%�0@��%�0@��%�0@��%t0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@��%�0@�U��Q�=tC@�\|f�}��t �}��uT�]��E��?��t?��u��é��t��u��é��u��é ��u��ø��ËE��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��@��@��@@��@��failed to create process. ��failed to get exit code from process. ��%s�� %s�-script.pyw�Cannot open %s �#!��#!python.exe��Cannot find Python executable %s ��Could not exec %s�� @@�p@@��@@��3@��1@��3@�� 1@��'hd�� l��`3��`��"��3��,��H3��"��(#��#��$��$��$��$��c$��k$��@��"��N%��x��.text$mn��0��.idata$5��1��.00cfg��$1��.CRT$XCA��(1��.CRT$XCAA��,1��.CRT$XCZ��01��.CRT$XIA��41��.CRT$XIAA��81��.CRT$XIAC��<1��.CRT$XIZ��@1��.CRT$XPA��D1��.CRT$XPZ��H1��.CRT$XTA��L1��.CRT$XTZ��P1��.rdata��3��.rdata$sxdata��3��\��.rdata$voltmd��`3��l��.rdata$zzzdbg��5��.rtc$IAA��5��.rtc$IZZ��5��.rtc$TAA��5��.rtc$TZZ��5��<��.xdata$x��6��.idata$2��6��.idata$3��6��.idata$4��8��.idata$6��@��.data��@��x��.bss��P��`��.rsrc$01��`P��.rsrc$02��,@�@@��N@�a@��6��8��0��L7��,9��T0��l7��;��t0��`7��;��h0��7��;��0��7��<��0��8��4<��1��7��V<��0��x7��v<��0��7��<��0��8��"8��>8��T8��j8��\|8��8��8��=��=��~=��h=��R=��8=��=��=��<��<��<��=��8��8��9��8��T9��H9��;��>9��:��:��;��:��v:��T:��&;��B;��^;��:��l;��\|;��:��2:��:��:��9��9��b9��p9��:��:��9��~9��;��;��;��;��9��:��9��9��9��CreateFileA�dGetFinalPathNameByHandleA��WaitForSingleObject�QGetExitCodeProcess��CreateProcessA��GetModuleFileNameA��SetConsoleCtrlHandler��GenerateConsoleCtrlEvent��KERNEL32.dll��H�memset��__current_exception��__current_exception_context�5�_except_handler4_common�VCRUNTIME140.dll��calloc��_makepath��_splitpath��__p___argc��__p___argv��__acrt_iob_func��__stdio_common_vfprintf� �__stdio_common_vsprintf��strncmp��strncpy�n�isspace�B�_seh_filter_exe�D�_set_app_type�.�__setusermatherr��_configure_narrow_argv��5�_initialize_narrow_environment���_get_initial_narrow_environment�8�_initterm�9�_initterm_e�X�exit��%�_exit�T�_set_fmode��_cexit��_c_exit�?�_register_thread_local_exe_atexit_callback��_configthreadlocale��_set_new_mode��__p__commode��6�_initialize_onexit_table��>�_register_onexit_function��_crt_atexit��_controlfp_s��j�terminate��_execv��I�_open�R�_read��_close��api-ms-win-crt-heap-l1-1-0.dll��api-ms-win-crt-filesystem-l1-1-0.dll��api-ms-win-crt-runtime-l1-1-0.dll�api-ms-win-crt-stdio-l1-1-0.dll�api-ms-win-crt-string-l1-1-0.dll��api-ms-win-crt-math-l1-1-0.dll��api-ms-win-crt-locale-l1-1-0.dll��api-ms-win-crt-process-l1-1-0.dll��UnhandledExceptionFilter��SetUnhandledExceptionFilter�,GetCurrentProcess��TerminateProcess��IsProcessorFeaturePresent�mQueryPerformanceCounter�-GetCurrentProcessId�1GetCurrentThreadId��GetSystemTimeAsFileTime��InitializeSListHead��IsDebuggerPresent��GetModuleHandleW��DN�@��0�� H��`P��}��<?xml version='1.0' encoding='UTF-8' standalone='yes'?> <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> <security> <requestedPrivileges> <requestedExecutionLevel level='asInvoker' uiAccess='false' /> </requestedPrivileges> </security> </trustInfo> </assembly> ��00'0[0�0J1u1�1�1�12 222:2�2�2�2�2�2�2+3>3g3&494s4M5S5w5�5�5�5�5�5�6�6�6>7I7�7�7(8P8Y8a8�8�8�8�8�8!949x9�9:3:H:M:R:s:x:�:�:�;�;�;�;�;�;�;�;�;�;�;�;�<<<<<#<+<3<;<G<P<U<[<e<o<<�<�<�<=4=g=�=�=�=�=�=�=�=�=�=�=>>> >>�>�>�>�>?'?0?=?S?�?�?�?�?�?� ��000%0�011;1z1�1�1�1�1�1222A2^2�2�2�2�2�2u3~3�3�3�3�3�3�3�3+444=4K4T4v4}4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�4�455555 5&5,52585>5D5J5T5��0��(��1(1418122L2P2X2�2�2�5�566��	11.5 KB	2026-01-20 12:58
📄 installer.py from __future__ import annotations import glob import itertools import os import subprocess import sys import tempfile import packaging.requirements import packaging.utils from . import _reqs from ._importlib import metadata from .warnings import SetuptoolsDeprecationWarning from .wheel import Wheel from distutils import log from distutils.errors import DistutilsError def _fixup_find_links(find_links): """Ensure find-links option end-up being a list of strings.""" if isinstance(find_links, str): return find_links.split() assert isinstance(find_links, (tuple, list)) return find_links def fetch_build_egg(dist, req): """Fetch an egg needed for building. Use pip/wheel to fetch/build a wheel.""" _DeprecatedInstaller.emit() _warn_wheel_not_available(dist) return _fetch_build_egg_no_warn(dist, req) def _present(req): return any(_dist_matches_req(dist, req) for dist in metadata.distributions()) def _fetch_build_eggs(dist, requires: _reqs._StrOrIter) -> list[metadata.Distribution]: _DeprecatedInstaller.emit(stacklevel=3) _warn_wheel_not_available(dist) parsed_reqs = _reqs.parse(requires) missing_reqs = itertools.filterfalse(_present, parsed_reqs) needed_reqs = ( req for req in missing_reqs if not req.marker or req.marker.evaluate() ) resolved_dists = [_fetch_build_egg_no_warn(dist, req) for req in needed_reqs] for dist in resolved_dists: # dist.locate_file('') is the directory containing EGG-INFO, where the importabl # contents can be found. sys.path.insert(0, str(dist.locate_file(''))) return resolved_dists def _dist_matches_req(egg_dist, req): return ( packaging.utils.canonicalize_name(egg_dist.name) == packaging.utils.canonicalize_name(req.name) and egg_dist.version in req.specifier ) def _fetch_build_egg_no_warn(dist, req): # noqa: C901 # is too complex (16) # FIXME # Ignore environment markers; if supplied, it is required. req = strip_marker(req) # Take easy_install options into account, but do not override relevant # pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll # take precedence. opts = dist.get_option_dict('easy_install') if 'allow_hosts' in opts: raise DistutilsError( 'the `allow-hosts` option is not supported ' 'when using pip to install requirements.' ) quiet = 'PIP_QUIET' not in os.environ and 'PIP_VERBOSE' not in os.environ if 'PIP_INDEX_URL' in os.environ: index_url = None elif 'index_url' in opts: index_url = opts['index_url'][1] else: index_url = None find_links = ( _fixup_find_links(opts['find_links'][1])[:] if 'find_links' in opts else [] ) if dist.dependency_links: find_links.extend(dist.dependency_links) eggs_dir = os.path.realpath(dist.get_egg_cache_dir()) cached_dists = metadata.Distribution.discover(path=glob.glob(f'{eggs_dir}/.egg')) for egg_dist in cached_dists: if _dist_matches_req(egg_dist, req): return egg_dist with tempfile.TemporaryDirectory() as tmpdir: cmd = [ sys.executable, '-m', 'pip', '--disable-pip-version-check', 'wheel', '--no-deps', '-w', tmpdir, ] if quiet: cmd.append('--quiet') if index_url is not None: cmd.extend(('--index-url', index_url)) for link in find_links or []: cmd.extend(('--find-links', link)) # If requirement is a PEP 508 direct URL, directly pass # the URL to pip, as `req @ url` does not work on the # command line. cmd.append(req.url or str(req)) try: subprocess.check_call(cmd) except subprocess.CalledProcessError as e: raise DistutilsError(str(e)) from e wheel = Wheel(glob.glob(os.path.join(tmpdir, '.whl'))[0]) dist_location = os.path.join(eggs_dir, wheel.egg_name()) wheel.install_as_egg(dist_location) return metadata.Distribution.at(dist_location + '/EGG-INFO') def strip_marker(req): """ Return a new requirement without the environment marker to avoid calling pip with something like `babel; extra == "i18n"`, which would always be ignored. """ # create a copy to avoid mutating the input req = packaging.requirements.Requirement(str(req)) req.marker = None return req def _warn_wheel_not_available(dist): try: metadata.distribution('wheel') except metadata.PackageNotFoundError: dist.announce('WARNING: The wheel package is not available.', log.WARN) class _DeprecatedInstaller(SetuptoolsDeprecationWarning): _SUMMARY = "setuptools.installer and fetch_build_eggs are deprecated." _DETAILS = """ Requirements should be satisfied by a PEP 517 installer. If you are using pip, you can try `pip install --use-pep517`. """ _DUE_DATE = 2025, 10, 31	4.97 KB	2026-01-20 12:58
📄 launch.py """ Launch the Python script on the command line after setuptools is bootstrapped via import. """ # Note that setuptools gets imported implicitly by the # invocation of this script using python -m setuptools.launch import sys import tokenize def run() -> None: """ Run the script in sys.argv[1] as if it had been invoked naturally. """ __builtins__ script_name = sys.argv[1] namespace = dict( __file__=script_name, __name__='__main__', __doc__=None, ) sys.argv[:] = sys.argv[1:] open_ = getattr(tokenize, 'open', open) with open_(script_name) as fid: script = fid.read() norm_script = script.replace('\\r\\n', '\\n') code = compile(norm_script, script_name, 'exec') exec(code, namespace) if __name__ == '__main__': run()	820 B	2026-01-20 12:58
📄 logging.py import inspect import logging import sys from . import monkey import distutils.log def _not_warning(record): return record.levelno < logging.WARNING def configure() -> None: """ Configure logging to emit warning and above to stderr and everything else to stdout. This behavior is provided for compatibility with distutils.log but may change in the future. """ err_handler = logging.StreamHandler() err_handler.setLevel(logging.WARNING) out_handler = logging.StreamHandler(sys.stdout) out_handler.addFilter(_not_warning) handlers = err_handler, out_handler logging.basicConfig( format="{message}", style='{', handlers=handlers, level=logging.DEBUG ) if inspect.ismodule(distutils.dist.log): monkey.patch_func(set_threshold, distutils.log, 'set_threshold') # For some reason `distutils.log` module is getting cached in `distutils.dist` # and then loaded again when patched, # implying: id(distutils.log) != id(distutils.dist.log). # Make sure the same module object is used everywhere: distutils.dist.log = distutils.log def set_threshold(level: int) -> int: logging.root.setLevel(level * 10) return set_threshold.unpatched(level)	1.23 KB	2026-01-20 12:58
📄 modified.py try: # Ensure a DistutilsError raised by these methods is the same as distutils.errors.DistutilsError from distutils._modified import ( newer, newer_group, newer_pairwise, newer_pairwise_group, ) except ImportError: # fallback for SETUPTOOLS_USE_DISTUTILS=stdlib, because _modified never existed in stdlib from ._distutils._modified import ( newer, newer_group, newer_pairwise, newer_pairwise_group, ) __all__ = ['newer', 'newer_pairwise', 'newer_group', 'newer_pairwise_group']	568 B	2026-01-20 12:58
📄 monkey.py """ Monkey patching of distutils. """ from __future__ import annotations import inspect import platform import sys import types from typing import TypeVar, cast, overload import distutils.filelist _T = TypeVar("_T") _UnpatchT = TypeVar("_UnpatchT", type, types.FunctionType) __all__: list[str] = [] """ Everything is private. Contact the project team if you think you need this functionality. """ def _get_mro(cls): """ Returns the bases classes for cls sorted by the MRO. Works around an issue on Jython where inspect.getmro will not return all base classes if multiple classes share the same name. Instead, this function will return a tuple containing the class itself, and the contents of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024. """ if platform.python_implementation() == "Jython": return (cls,) + cls.__bases__ return inspect.getmro(cls) @overload def get_unpatched(item: _UnpatchT) -> _UnpatchT: ... @overload def get_unpatched(item: object) -> None: ... def get_unpatched( item: type \| types.FunctionType \| object, ) -> type \| types.FunctionType \| None: if isinstance(item, type): return get_unpatched_class(item) if isinstance(item, types.FunctionType): return get_unpatched_function(item) return None def get_unpatched_class(cls: type[_T]) -> type[_T]: """Protect against re-patching the distutils if reloaded Also ensures that no other distutils extension monkeypatched the distutils first. """ external_bases = ( cast(type[_T], cls) for cls in _get_mro(cls) if not cls.__module__.startswith('setuptools') ) base = next(external_bases) if not base.__module__.startswith('distutils'): msg = f"distutils has already been patched by {cls!r}" raise AssertionError(msg) return base def patch_all(): import setuptools # we can't patch distutils.cmd, alas distutils.core.Command = setuptools.Command # type: ignore[misc,assignment] # monkeypatching _patch_distribution_metadata() # Install Distribution throughout the distutils for module in distutils.dist, distutils.core, distutils.cmd: module.Distribution = setuptools.dist.Distribution # Install the patched Extension distutils.core.Extension = setuptools.extension.Extension # type: ignore[misc,assignment] # monkeypatching distutils.extension.Extension = setuptools.extension.Extension # type: ignore[misc,assignment] # monkeypatching if 'distutils.command.build_ext' in sys.modules: sys.modules[ 'distutils.command.build_ext' ].Extension = setuptools.extension.Extension def _patch_distribution_metadata(): from . import _core_metadata """Patch write_pkg_file and read_pkg_file for higher metadata standards""" for attr in ( 'write_pkg_info', 'write_pkg_file', 'read_pkg_file', 'get_metadata_version', 'get_fullname', ): new_val = getattr(_core_metadata, attr) setattr(distutils.dist.DistributionMetadata, attr, new_val) def patch_func(replacement, target_mod, func_name): """ Patch func_name in target_mod with replacement Important - original must be resolved by name to avoid patching an already patched function. """ original = getattr(target_mod, func_name) # set the 'unpatched' attribute on the replacement to # point to the original. vars(replacement).setdefault('unpatched', original) # replace the function in the original module setattr(target_mod, func_name, replacement) def get_unpatched_function(candidate): return candidate.unpatched	3.63 KB	2026-01-20 12:58
📄 msvc.py """ Environment info about Microsoft Compilers. >>> getfixture('windows_only') >>> ei = EnvironmentInfo('amd64') """ from __future__ import annotations import contextlib import itertools import json import os import os.path import platform from typing import TYPE_CHECKING, TypedDict from more_itertools import unique_everseen import distutils.errors if TYPE_CHECKING: from typing_extensions import LiteralString, NotRequired # https://github.com/python/mypy/issues/8166 if not TYPE_CHECKING and platform.system() == 'Windows': import winreg from os import environ else: # Mock winreg and environ so the module can be imported on this platform. class winreg: HKEY_USERS = None HKEY_CURRENT_USER = None HKEY_LOCAL_MACHINE = None HKEY_CLASSES_ROOT = None environ: dict[str, str] = dict() class PlatformInfo: """ Current and Target Architectures information. Parameters ---------- arch: str Target architecture. """ current_cpu = environ.get('processor_architecture', '').lower() def __init__(self, arch) -> None: self.arch = arch.lower().replace('x64', 'amd64') @property def target_cpu(self): """ Return Target CPU architecture. Return ------ str Target CPU """ return self.arch[self.arch.find('_') + 1 :] def target_is_x86(self): """ Return True if target CPU is x86 32 bits.. Return ------ bool CPU is x86 32 bits """ return self.target_cpu == 'x86' def current_is_x86(self): """ Return True if current CPU is x86 32 bits.. Return ------ bool CPU is x86 32 bits """ return self.current_cpu == 'x86' def current_dir(self, hidex86=False, x64=False) -> str: """ Current platform specific subfolder. Parameters ---------- hidex86: bool return '' and not '\x86' if architecture is x86. x64: bool return '\x64' and not '\amd64' if architecture is amd64. Return ------ str subfolder: '\target', or '' (see hidex86 parameter) """ return ( '' if (self.current_cpu == 'x86' and hidex86) else r'\x64' if (self.current_cpu == 'amd64' and x64) else rf'\{self.current_cpu}' ) def target_dir(self, hidex86=False, x64=False) -> str: r""" Target platform specific subfolder. Parameters ---------- hidex86: bool return '' and not '\x86' if architecture is x86. x64: bool return '\x64' and not '\amd64' if architecture is amd64. Return ------ str subfolder: '\current', or '' (see hidex86 parameter) """ return ( '' if (self.target_cpu == 'x86' and hidex86) else r'\x64' if (self.target_cpu == 'amd64' and x64) else rf'\{self.target_cpu}' ) def cross_dir(self, forcex86=False): r""" Cross platform specific subfolder. Parameters ---------- forcex86: bool Use 'x86' as current architecture even if current architecture is not x86. Return ------ str subfolder: '' if target architecture is current architecture, '\current_target' if not. """ current = 'x86' if forcex86 else self.current_cpu return ( '' if self.target_cpu == current else self.target_dir().replace('\\', f'\\{current}_') ) class RegistryInfo: """ Microsoft Visual Studio related registry information. Parameters ---------- platform_info: PlatformInfo "PlatformInfo" instance. """ HKEYS = ( winreg.HKEY_USERS, winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CLASSES_ROOT, ) def __init__(self, platform_info) -> None: self.pi = platform_info @property def visualstudio(self) -> str: """ Microsoft Visual Studio root registry key. Return ------ str Registry key """ return 'VisualStudio' @property def sxs(self): """ Microsoft Visual Studio SxS registry key. Return ------ str Registry key """ return os.path.join(self.visualstudio, 'SxS') @property def vc(self): """ Microsoft Visual C++ VC7 registry key. Return ------ str Registry key """ return os.path.join(self.sxs, 'VC7') @property def vs(self): """ Microsoft Visual Studio VS7 registry key. Return ------ str Registry key """ return os.path.join(self.sxs, 'VS7') @property def vc_for_python(self) -> str: """ Microsoft Visual C++ for Python registry key. Return ------ str Registry key """ return r'DevDiv\VCForPython' @property def microsoft_sdk(self) -> str: """ Microsoft SDK registry key. Return ------ str Registry key """ return 'Microsoft SDKs' @property def windows_sdk(self): """ Microsoft Windows/Platform SDK registry key. Return ------ str Registry key """ return os.path.join(self.microsoft_sdk, 'Windows') @property def netfx_sdk(self): """ Microsoft .NET Framework SDK registry key. Return ------ str Registry key """ return os.path.join(self.microsoft_sdk, 'NETFXSDK') @property def windows_kits_roots(self) -> str: """ Microsoft Windows Kits Roots registry key. Return ------ str Registry key """ return r'Windows Kits\Installed Roots' def microsoft(self, key, x86=False): """ Return key in Microsoft software registry. Parameters ---------- key: str Registry key path where look. x86: str Force x86 software registry. Return ------ str Registry key """ node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node' return os.path.join('Software', node64, 'Microsoft', key) def lookup(self, key, name): """ Look for values in registry in Microsoft software registry. Parameters ---------- key: str Registry key path where look. name: str Value name to find. Return ------ str value """ key_read = winreg.KEY_READ openkey = winreg.OpenKey closekey = winreg.CloseKey ms = self.microsoft for hkey in self.HKEYS: bkey = None try: bkey = openkey(hkey, ms(key), 0, key_read) except OSError: if not self.pi.current_is_x86(): try: bkey = openkey(hkey, ms(key, True), 0, key_read) except OSError: continue else: continue try: return winreg.QueryValueEx(bkey, name)[0] except OSError: pass finally: if bkey: closekey(bkey) return None class SystemInfo: """ Microsoft Windows and Visual Studio related system information. Parameters ---------- registry_info: RegistryInfo "RegistryInfo" instance. vc_ver: float Required Microsoft Visual C++ version. """ # Variables and properties in this class use originals CamelCase variables # names from Microsoft source files for more easy comparison. WinDir = environ.get('WinDir', '') ProgramFiles = environ.get('ProgramFiles', '') ProgramFilesx86 = environ.get('ProgramFiles(x86)', ProgramFiles) def __init__(self, registry_info, vc_ver=None) -> None: self.ri = registry_info self.pi = self.ri.pi self.known_vs_paths = self.find_programdata_vs_vers() # Except for VS15+, VC version is aligned with VS version self.vs_ver = self.vc_ver = vc_ver or self._find_latest_available_vs_ver() def _find_latest_available_vs_ver(self): """ Find the latest VC version Return ------ float version """ reg_vc_vers = self.find_reg_vs_vers() if not (reg_vc_vers or self.known_vs_paths): raise distutils.errors.DistutilsPlatformError( 'No Microsoft Visual C++ version found' ) vc_vers = set(reg_vc_vers) vc_vers.update(self.known_vs_paths) return sorted(vc_vers)[-1] def find_reg_vs_vers(self): """ Find Microsoft Visual Studio versions available in registry. Return ------ list of float Versions """ ms = self.ri.microsoft vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs) vs_vers = [] for hkey, key in itertools.product(self.ri.HKEYS, vckeys): try: bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ) except OSError: continue with bkey: subkeys, values, _ = winreg.QueryInfoKey(bkey) for i in range(values): with contextlib.suppress(ValueError): ver = float(winreg.EnumValue(bkey, i)[0]) if ver not in vs_vers: vs_vers.append(ver) for i in range(subkeys): with contextlib.suppress(ValueError): ver = float(winreg.EnumKey(bkey, i)) if ver not in vs_vers: vs_vers.append(ver) return sorted(vs_vers) def find_programdata_vs_vers(self) -> dict[float, str]: r""" Find Visual studio 2017+ versions from information in "C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances". Return ------ dict float version as key, path as value. """ vs_versions: dict[float, str] = {} instances_dir = r'C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances' try: hashed_names = os.listdir(instances_dir) except OSError: # Directory not exists with all Visual Studio versions return vs_versions for name in hashed_names: try: # Get VS installation path from "state.json" file state_path = os.path.join(instances_dir, name, 'state.json') with open(state_path, 'rt', encoding='utf-8') as state_file: state = json.load(state_file) vs_path = state['installationPath'] # Raises OSError if this VS installation does not contain VC os.listdir(os.path.join(vs_path, r'VC\Tools\MSVC')) # Store version and path vs_versions[self._as_float_version(state['installationVersion'])] = ( vs_path ) except (OSError, KeyError): # Skip if "state.json" file is missing or bad format continue return vs_versions @staticmethod def _as_float_version(version): """ Return a string version as a simplified float version (major.minor) Parameters ---------- version: str Version. Return ------ float version """ return float('.'.join(version.split('.')[:2])) @property def VSInstallDir(self): """ Microsoft Visual Studio directory. Return ------ str path """ # Default path default = os.path.join( self.ProgramFilesx86, f'Microsoft Visual Studio {self.vs_ver:0.1f}' ) # Try to get path from registry, if fail use default path return self.ri.lookup(self.ri.vs, f'{self.vs_ver:0.1f}') or default @property def VCInstallDir(self): """ Microsoft Visual C++ directory. Return ------ str path """ path = self._guess_vc() or self._guess_vc_legacy() if not os.path.isdir(path): msg = 'Microsoft Visual C++ directory not found' raise distutils.errors.DistutilsPlatformError(msg) return path def _guess_vc(self): """ Locate Visual C++ for VS2017+. Return ------ str path """ if self.vs_ver <= 14.0: return '' try: # First search in known VS paths vs_dir = self.known_vs_paths[self.vs_ver] except KeyError: # Else, search with path from registry vs_dir = self.VSInstallDir guess_vc = os.path.join(vs_dir, r'VC\Tools\MSVC') # Subdir with VC exact version as name try: # Update the VC version with real one instead of VS version vc_ver = os.listdir(guess_vc)[-1] self.vc_ver = self._as_float_version(vc_ver) return os.path.join(guess_vc, vc_ver) except (OSError, IndexError): return '' def _guess_vc_legacy(self): """ Locate Visual C++ for versions prior to 2017. Return ------ str path """ default = os.path.join( self.ProgramFilesx86, rf'Microsoft Visual Studio {self.vs_ver:0.1f}\VC', ) # Try to get "VC++ for Python" path from registry as default path reg_path = os.path.join(self.ri.vc_for_python, f'{self.vs_ver:0.1f}') python_vc = self.ri.lookup(reg_path, 'installdir') default_vc = os.path.join(python_vc, 'VC') if python_vc else default # Try to get path from registry, if fail use default path return self.ri.lookup(self.ri.vc, f'{self.vs_ver:0.1f}') or default_vc @property def WindowsSdkVersion(self) -> tuple[LiteralString, ...]: """ Microsoft Windows SDK versions for specified MSVC++ version. Return ------ tuple of str versions """ if self.vs_ver <= 9.0: return '7.0', '6.1', '6.0a' elif self.vs_ver == 10.0: return '7.1', '7.0a' elif self.vs_ver == 11.0: return '8.0', '8.0a' elif self.vs_ver == 12.0: return '8.1', '8.1a' elif self.vs_ver >= 14.0: return '10.0', '8.1' return () @property def WindowsSdkLastVersion(self): """ Microsoft Windows SDK last version. Return ------ str version """ return self._use_last_dir_name(os.path.join(self.WindowsSdkDir, 'lib')) @property def WindowsSdkDir(self) -> str \| None: # noqa: C901 # is too complex (12) # FIXME """ Microsoft Windows SDK directory. Return ------ str path """ sdkdir: str \| None = '' for ver in self.WindowsSdkVersion: # Try to get it from registry loc = os.path.join(self.ri.windows_sdk, f'v{ver}') sdkdir = self.ri.lookup(loc, 'installationfolder') if sdkdir: break if not sdkdir or not os.path.isdir(sdkdir): # Try to get "VC++ for Python" version from registry path = os.path.join(self.ri.vc_for_python, f'{self.vc_ver:0.1f}') install_base = self.ri.lookup(path, 'installdir') if install_base: sdkdir = os.path.join(install_base, 'WinSDK') if not sdkdir or not os.path.isdir(sdkdir): # If fail, use default new path for ver in self.WindowsSdkVersion: intver = ver[: ver.rfind('.')] path = rf'Microsoft SDKs\Windows Kits\{intver}' d = os.path.join(self.ProgramFiles, path) if os.path.isdir(d): sdkdir = d if not sdkdir or not os.path.isdir(sdkdir): # If fail, use default old path for ver in self.WindowsSdkVersion: path = rf'Microsoft SDKs\Windows\v{ver}' d = os.path.join(self.ProgramFiles, path) if os.path.isdir(d): sdkdir = d if not sdkdir: # If fail, use Platform SDK sdkdir = os.path.join(self.VCInstallDir, 'PlatformSDK') return sdkdir @property def WindowsSDKExecutablePath(self): """ Microsoft Windows SDK executable directory. Return ------ str path """ # Find WinSDK NetFx Tools registry dir name if self.vs_ver <= 11.0: netfxver = 35 arch = '' else: netfxver = 40 hidex86 = True if self.vs_ver <= 12.0 else False arch = self.pi.current_dir(x64=True, hidex86=hidex86).replace('\\', '-') fx = f'WinSDK-NetFx{netfxver}Tools{arch}' # list all possibles registry paths regpaths = [] if self.vs_ver >= 14.0: for ver in self.NetFxSdkVersion: regpaths += [os.path.join(self.ri.netfx_sdk, ver, fx)] for ver in self.WindowsSdkVersion: regpaths += [os.path.join(self.ri.windows_sdk, f'v{ver}A', fx)] # Return installation folder from the more recent path for path in regpaths: execpath = self.ri.lookup(path, 'installationfolder') if execpath: return execpath return None @property def FSharpInstallDir(self): """ Microsoft Visual F# directory. Return ------ str path """ path = os.path.join(self.ri.visualstudio, rf'{self.vs_ver:0.1f}\Setup\F#') return self.ri.lookup(path, 'productdir') or '' @property def UniversalCRTSdkDir(self): """ Microsoft Universal CRT SDK directory. Return ------ str path """ # Set Kit Roots versions for specified MSVC++ version vers = ('10', '81') if self.vs_ver >= 14.0 else () # Find path of the more recent Kit for ver in vers: sdkdir = self.ri.lookup(self.ri.windows_kits_roots, f'kitsroot{ver}') if sdkdir: return sdkdir or '' return None @property def UniversalCRTSdkLastVersion(self): """ Microsoft Universal C Runtime SDK last version. Return ------ str version """ return self._use_last_dir_name(os.path.join(self.UniversalCRTSdkDir, 'lib')) @property def NetFxSdkVersion(self): """ Microsoft .NET Framework SDK versions. Return ------ tuple of str versions """ # Set FxSdk versions for specified VS version return ( ('4.7.2', '4.7.1', '4.7', '4.6.2', '4.6.1', '4.6', '4.5.2', '4.5.1', '4.5') if self.vs_ver >= 14.0 else () ) @property def NetFxSdkDir(self): """ Microsoft .NET Framework SDK directory. Return ------ str path """ sdkdir = '' for ver in self.NetFxSdkVersion: loc = os.path.join(self.ri.netfx_sdk, ver) sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder') if sdkdir: break return sdkdir @property def FrameworkDir32(self): """ Microsoft .NET Framework 32bit directory. Return ------ str path """ # Default path guess_fw = os.path.join(self.WinDir, r'Microsoft.NET\Framework') # Try to get path from registry, if fail use default path return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw @property def FrameworkDir64(self): """ Microsoft .NET Framework 64bit directory. Return ------ str path """ # Default path guess_fw = os.path.join(self.WinDir, r'Microsoft.NET\Framework64') # Try to get path from registry, if fail use default path return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw @property def FrameworkVersion32(self) -> tuple[str, ...]: """ Microsoft .NET Framework 32bit versions. Return ------ tuple of str versions """ return self._find_dot_net_versions(32) @property def FrameworkVersion64(self) -> tuple[str, ...]: """ Microsoft .NET Framework 64bit versions. Return ------ tuple of str versions """ return self._find_dot_net_versions(64) def _find_dot_net_versions(self, bits) -> tuple[str, ...]: """ Find Microsoft .NET Framework versions. Parameters ---------- bits: int Platform number of bits: 32 or 64. Return ------ tuple of str versions """ # Find actual .NET version in registry reg_ver = self.ri.lookup(self.ri.vc, f'frameworkver{bits}') dot_net_dir = getattr(self, f'FrameworkDir{bits}') ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or '' # Set .NET versions for specified MSVC++ version if self.vs_ver >= 12.0: return ver, 'v4.0' elif self.vs_ver >= 10.0: return 'v4.0.30319' if ver.lower()[:2] != 'v4' else ver, 'v3.5' elif self.vs_ver == 9.0: return 'v3.5', 'v2.0.50727' elif self.vs_ver == 8.0: return 'v3.0', 'v2.0.50727' return () @staticmethod def _use_last_dir_name(path, prefix=''): """ Return name of the last dir in path or '' if no dir found. Parameters ---------- path: str Use dirs in this path prefix: str Use only dirs starting by this prefix Return ------ str name """ matching_dirs = ( dir_name for dir_name in reversed(os.listdir(path)) if os.path.isdir(os.path.join(path, dir_name)) and dir_name.startswith(prefix) ) return next(matching_dirs, None) or '' class _EnvironmentDict(TypedDict): include: str lib: str libpath: str path: str py_vcruntime_redist: NotRequired[str \| None] class EnvironmentInfo: """ Return environment variables for specified Microsoft Visual C++ version and platform : Lib, Include, Path and libpath. This function is compatible with Microsoft Visual C++ 9.0 to 14.X. Script created by analysing Microsoft environment configuration files like "vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ... Parameters ---------- arch: str Target architecture. vc_ver: float Required Microsoft Visual C++ version. If not set, autodetect the last version. vc_min_ver: float Minimum Microsoft Visual C++ version. """ # Variables and properties in this class use originals CamelCase variables # names from Microsoft source files for more easy comparison. def __init__(self, arch, vc_ver=None, vc_min_ver=0) -> None: self.pi = PlatformInfo(arch) self.ri = RegistryInfo(self.pi) self.si = SystemInfo(self.ri, vc_ver) if self.vc_ver < vc_min_ver: err = 'No suitable Microsoft Visual C++ version found' raise distutils.errors.DistutilsPlatformError(err) @property def vs_ver(self): """ Microsoft Visual Studio. Return ------ float version """ return self.si.vs_ver @property def vc_ver(self): """ Microsoft Visual C++ version. Return ------ float version """ return self.si.vc_ver @property def VSTools(self): """ Microsoft Visual Studio Tools. Return ------ list of str paths """ paths = [r'Common7\IDE', r'Common7\Tools'] if self.vs_ver >= 14.0: arch_subdir = self.pi.current_dir(hidex86=True, x64=True) paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow'] paths += [r'Team Tools\Performance Tools'] paths += [rf'Team Tools\Performance Tools{arch_subdir}'] return [os.path.join(self.si.VSInstallDir, path) for path in paths] @property def VCIncludes(self): """ Microsoft Visual C++ & Microsoft Foundation Class Includes. Return ------ list of str paths """ return [ os.path.join(self.si.VCInstallDir, 'Include'), os.path.join(self.si.VCInstallDir, r'ATLMFC\Include'), ] @property def VCLibraries(self): """ Microsoft Visual C++ & Microsoft Foundation Class Libraries. Return ------ list of str paths """ if self.vs_ver >= 15.0: arch_subdir = self.pi.target_dir(x64=True) else: arch_subdir = self.pi.target_dir(hidex86=True) paths = [f'Lib{arch_subdir}', rf'ATLMFC\Lib{arch_subdir}'] if self.vs_ver >= 14.0: paths += [rf'Lib\store{arch_subdir}'] return [os.path.join(self.si.VCInstallDir, path) for path in paths] @property def VCStoreRefs(self): """ Microsoft Visual C++ store references Libraries. Return ------ list of str paths """ if self.vs_ver < 14.0: return [] return [os.path.join(self.si.VCInstallDir, r'Lib\store\references')] @property def VCTools(self): """ Microsoft Visual C++ Tools. Return ------ list of str paths When host CPU is ARM, the tools should be found for ARM. >>> getfixture('windows_only') >>> mp = getfixture('monkeypatch') >>> mp.setattr(PlatformInfo, 'current_cpu', 'arm64') >>> ei = EnvironmentInfo(arch='irrelevant') >>> paths = ei.VCTools >>> any('HostARM64' in path for path in paths) True """ si = self.si tools = [os.path.join(si.VCInstallDir, 'VCPackages')] forcex86 = True if self.vs_ver <= 10.0 else False arch_subdir = self.pi.cross_dir(forcex86) if arch_subdir: tools += [os.path.join(si.VCInstallDir, f'Bin{arch_subdir}')] if self.vs_ver == 14.0: path = f'Bin{self.pi.current_dir(hidex86=True)}' tools += [os.path.join(si.VCInstallDir, path)] elif self.vs_ver >= 15.0: host_id = self.pi.current_cpu.replace('amd64', 'x64').upper() host_dir = os.path.join('bin', f'Host{host_id}%s') tools += [ os.path.join(si.VCInstallDir, host_dir % self.pi.target_dir(x64=True)) ] if self.pi.current_cpu != self.pi.target_cpu: tools += [ os.path.join( si.VCInstallDir, host_dir % self.pi.current_dir(x64=True) ) ] else: tools += [os.path.join(si.VCInstallDir, 'Bin')] return tools @property def OSLibraries(self): """ Microsoft Windows SDK Libraries. Return ------ list of str paths """ if self.vs_ver <= 10.0: arch_subdir = self.pi.target_dir(hidex86=True, x64=True) return [os.path.join(self.si.WindowsSdkDir, f'Lib{arch_subdir}')] else: arch_subdir = self.pi.target_dir(x64=True) lib = os.path.join(self.si.WindowsSdkDir, 'lib') libver = self._sdk_subdir return [os.path.join(lib, f'{libver}um{arch_subdir}')] @property def OSIncludes(self): """ Microsoft Windows SDK Include. Return ------ list of str paths """ include = os.path.join(self.si.WindowsSdkDir, 'include') if self.vs_ver <= 10.0: return [include, os.path.join(include, 'gl')] else: if self.vs_ver >= 14.0: sdkver = self._sdk_subdir else: sdkver = '' return [ os.path.join(include, f'{sdkver}shared'), os.path.join(include, f'{sdkver}um'), os.path.join(include, f'{sdkver}winrt'), ] @property def OSLibpath(self): """ Microsoft Windows SDK Libraries Paths. Return ------ list of str paths """ ref = os.path.join(self.si.WindowsSdkDir, 'References') libpath = [] if self.vs_ver <= 9.0: libpath += self.OSLibraries if self.vs_ver >= 11.0: libpath += [os.path.join(ref, r'CommonConfiguration\Neutral')] if self.vs_ver >= 14.0: libpath += [ ref, os.path.join(self.si.WindowsSdkDir, 'UnionMetadata'), os.path.join(ref, 'Windows.Foundation.UniversalApiContract', '1.0.0.0'), os.path.join(ref, 'Windows.Foundation.FoundationContract', '1.0.0.0'), os.path.join( ref, 'Windows.Networking.Connectivity.WwanContract', '1.0.0.0' ), os.path.join( self.si.WindowsSdkDir, 'ExtensionSDKs', 'Microsoft.VCLibs', f'{self.vs_ver:0.1f}', 'References', 'CommonConfiguration', 'neutral', ), ] return libpath @property def SdkTools(self): """ Microsoft Windows SDK Tools. Return ------ list of str paths """ return list(self._sdk_tools()) def _sdk_tools(self): """ Microsoft Windows SDK Tools paths generator. Return ------ generator of str paths """ if self.vs_ver < 15.0: bin_dir = 'Bin' if self.vs_ver <= 11.0 else r'Bin\x86' yield os.path.join(self.si.WindowsSdkDir, bin_dir) if not self.pi.current_is_x86(): arch_subdir = self.pi.current_dir(x64=True) path = f'Bin{arch_subdir}' yield os.path.join(self.si.WindowsSdkDir, path) if self.vs_ver in (10.0, 11.0): if self.pi.target_is_x86(): arch_subdir = '' else: arch_subdir = self.pi.current_dir(hidex86=True, x64=True) path = rf'Bin\NETFX 4.0 Tools{arch_subdir}' yield os.path.join(self.si.WindowsSdkDir, path) elif self.vs_ver >= 15.0: path = os.path.join(self.si.WindowsSdkDir, 'Bin') arch_subdir = self.pi.current_dir(x64=True) sdkver = self.si.WindowsSdkLastVersion yield os.path.join(path, f'{sdkver}{arch_subdir}') if self.si.WindowsSDKExecutablePath: yield self.si.WindowsSDKExecutablePath @property def _sdk_subdir(self): """ Microsoft Windows SDK version subdir. Return ------ str subdir """ ucrtver = self.si.WindowsSdkLastVersion return (f'{ucrtver}\\') if ucrtver else '' @property def SdkSetup(self): """ Microsoft Windows SDK Setup. Return ------ list of str paths """ if self.vs_ver > 9.0: return [] return [os.path.join(self.si.WindowsSdkDir, 'Setup')] @property def FxTools(self): """ Microsoft .NET Framework Tools. Return ------ list of str paths """ pi = self.pi si = self.si if self.vs_ver <= 10.0: include32 = True include64 = not pi.target_is_x86() and not pi.current_is_x86() else: include32 = pi.target_is_x86() or pi.current_is_x86() include64 = pi.current_cpu == 'amd64' or pi.target_cpu == 'amd64' tools = [] if include32: tools += [ os.path.join(si.FrameworkDir32, ver) for ver in si.FrameworkVersion32 ] if include64: tools += [ os.path.join(si.FrameworkDir64, ver) for ver in si.FrameworkVersion64 ] return tools @property def NetFxSDKLibraries(self): """ Microsoft .Net Framework SDK Libraries. Return ------ list of str paths """ if self.vs_ver < 14.0 or not self.si.NetFxSdkDir: return [] arch_subdir = self.pi.target_dir(x64=True) return [os.path.join(self.si.NetFxSdkDir, rf'lib\um{arch_subdir}')] @property def NetFxSDKIncludes(self): """ Microsoft .Net Framework SDK Includes. Return ------ list of str paths """ if self.vs_ver < 14.0 or not self.si.NetFxSdkDir: return [] return [os.path.join(self.si.NetFxSdkDir, r'include\um')] @property def VsTDb(self): """ Microsoft Visual Studio Team System Database. Return ------ list of str paths """ return [os.path.join(self.si.VSInstallDir, r'VSTSDB\Deploy')] @property def MSBuild(self): """ Microsoft Build Engine. Return ------ list of str paths """ if self.vs_ver < 12.0: return [] elif self.vs_ver < 15.0: base_path = self.si.ProgramFilesx86 arch_subdir = self.pi.current_dir(hidex86=True) else: base_path = self.si.VSInstallDir arch_subdir = '' path = rf'MSBuild\{self.vs_ver:0.1f}\bin{arch_subdir}' build = [os.path.join(base_path, path)] if self.vs_ver >= 15.0: # Add Roslyn C# & Visual Basic Compiler build += [os.path.join(base_path, path, 'Roslyn')] return build @property def HTMLHelpWorkshop(self): """ Microsoft HTML Help Workshop. Return ------ list of str paths """ if self.vs_ver < 11.0: return [] return [os.path.join(self.si.ProgramFilesx86, 'HTML Help Workshop')] @property def UCRTLibraries(self): """ Microsoft Universal C Runtime SDK Libraries. Return ------ list of str paths """ if self.vs_ver < 14.0: return [] arch_subdir = self.pi.target_dir(x64=True) lib = os.path.join(self.si.UniversalCRTSdkDir, 'lib') ucrtver = self._ucrt_subdir return [os.path.join(lib, f'{ucrtver}ucrt{arch_subdir}')] @property def UCRTIncludes(self): """ Microsoft Universal C Runtime SDK Include. Return ------ list of str paths """ if self.vs_ver < 14.0: return [] include = os.path.join(self.si.UniversalCRTSdkDir, 'include') return [os.path.join(include, f'{self._ucrt_subdir}ucrt')] @property def _ucrt_subdir(self): """ Microsoft Universal C Runtime SDK version subdir. Return ------ str subdir """ ucrtver = self.si.UniversalCRTSdkLastVersion return (f'{ucrtver}\\') if ucrtver else '' @property def FSharp(self): """ Microsoft Visual F#. Return ------ list of str paths """ if 11.0 > self.vs_ver > 12.0: return [] return [self.si.FSharpInstallDir] @property def VCRuntimeRedist(self) -> str \| None: """ Microsoft Visual C++ runtime redistributable dll. Returns the first suitable path found or None. """ vcruntime = f'vcruntime{self.vc_ver}0.dll' arch_subdir = self.pi.target_dir(x64=True).strip('\\') # Installation prefixes candidates prefixes = [] tools_path = self.si.VCInstallDir redist_path = os.path.dirname(tools_path.replace(r'\Tools', r'\Redist')) if os.path.isdir(redist_path): # Redist version may not be exactly the same as tools redist_path = os.path.join(redist_path, os.listdir(redist_path)[-1]) prefixes += [redist_path, os.path.join(redist_path, 'onecore')] prefixes += [os.path.join(tools_path, 'redist')] # VS14 legacy path # CRT directory crt_dirs = ( f'Microsoft.VC{self.vc_ver * 10}.CRT', # Sometime store in directory with VS version instead of VC f'Microsoft.VC{int(self.vs_ver) * 10}.CRT', ) # vcruntime path candidate_paths = ( os.path.join(prefix, arch_subdir, crt_dir, vcruntime) for (prefix, crt_dir) in itertools.product(prefixes, crt_dirs) ) return next(filter(os.path.isfile, candidate_paths), None) # type: ignore[arg-type] #python/mypy#12682 def return_env(self, exists: bool = True) -> _EnvironmentDict: """ Return environment dict. Parameters ---------- exists: bool It True, only return existing paths. Return ------ dict environment """ env = _EnvironmentDict( include=self._build_paths( 'include', [ self.VCIncludes, self.OSIncludes, self.UCRTIncludes, self.NetFxSDKIncludes, ], exists, ), lib=self._build_paths( 'lib', [ self.VCLibraries, self.OSLibraries, self.FxTools, self.UCRTLibraries, self.NetFxSDKLibraries, ], exists, ), libpath=self._build_paths( 'libpath', [self.VCLibraries, self.FxTools, self.VCStoreRefs, self.OSLibpath], exists, ), path=self._build_paths( 'path', [ self.VCTools, self.VSTools, self.VsTDb, self.SdkTools, self.SdkSetup, self.FxTools, self.MSBuild, self.HTMLHelpWorkshop, self.FSharp, ], exists, ), ) if self.vs_ver >= 14 and self.VCRuntimeRedist: env['py_vcruntime_redist'] = self.VCRuntimeRedist return env def _build_paths(self, name, spec_path_lists, exists): """ Given an environment variable name and specified paths, return a pathsep-separated string of paths containing unique, extant, directories from those paths and from the environment variable. Raise an error if no paths are resolved. Parameters ---------- name: str Environment variable name spec_path_lists: list of str Paths exists: bool It True, only return existing paths. Return ------ str Pathsep-separated paths """ # flatten spec_path_lists spec_paths = itertools.chain.from_iterable(spec_path_lists) env_paths = environ.get(name, '').split(os.pathsep) paths = itertools.chain(spec_paths, env_paths) extant_paths = list(filter(os.path.isdir, paths)) if exists else paths if not extant_paths: msg = f"{name.upper()} environment variable is empty" raise distutils.errors.DistutilsPlatformError(msg) unique_paths = unique_everseen(extant_paths) return os.pathsep.join(unique_paths)	40.66 KB	2026-01-20 12:58
📄 namespaces.py import itertools import os from .compat import py312 from distutils import log flatten = itertools.chain.from_iterable class Installer: nspkg_ext = '-nspkg.pth' def install_namespaces(self) -> None: nsp = self._get_all_ns_packages() if not nsp: return filename = self._get_nspkg_file() self.outputs.append(filename) log.info("Installing %s", filename) lines = map(self._gen_nspkg_line, nsp) if self.dry_run: # always generate the lines, even in dry run list(lines) return with open(filename, 'wt', encoding=py312.PTH_ENCODING) as f: # Python<3.13 requires encoding="locale" instead of "utf-8" # See: python/cpython#77102 f.writelines(lines) def uninstall_namespaces(self) -> None: filename = self._get_nspkg_file() if not os.path.exists(filename): return log.info("Removing %s", filename) os.remove(filename) def _get_nspkg_file(self): filename, _ = os.path.splitext(self._get_target()) return filename + self.nspkg_ext def _get_target(self): return self.target _nspkg_tmpl = ( "import sys, types, os", "p = os.path.join(%(root)s, *%(pth)r)", "importlib = __import__('importlib.util')", "__import__('importlib.machinery')", ( "m = " "sys.modules.setdefault(%(pkg)r, " "importlib.util.module_from_spec(" "importlib.machinery.PathFinder.find_spec(%(pkg)r, " "[os.path.dirname(p)])))" ), ("m = m or sys.modules.setdefault(%(pkg)r, types.ModuleType(%(pkg)r))"), "mp = (m or []) and m.__dict__.setdefault('__path__',[])", "(p not in mp) and mp.append(p)", ) "lines for the namespace installer" _nspkg_tmpl_multi = ('m and setattr(sys.modules[%(parent)r], %(child)r, m)',) "additional line(s) when a parent package is indicated" def _get_root(self): return "sys._getframe(1).f_locals['sitedir']" def _gen_nspkg_line(self, pkg): pth = tuple(pkg.split('.')) root = self._get_root() tmpl_lines = self._nspkg_tmpl parent, sep, child = pkg.rpartition('.') if parent: tmpl_lines += self._nspkg_tmpl_multi return ';'.join(tmpl_lines) % locals() + '\n' def _get_all_ns_packages(self): """Return sorted list of all package namespaces""" pkgs = self.distribution.namespace_packages or [] return sorted(set(flatten(map(self._pkg_names, pkgs)))) @staticmethod def _pkg_names(pkg): """ Given a namespace package, yield the components of that package. >>> names = Installer._pkg_names('a.b.c') >>> set(names) == set(['a', 'a.b', 'a.b.c']) True """ parts = pkg.split('.') while parts: yield '.'.join(parts) parts.pop() class DevelopInstaller(Installer): def _get_root(self): return repr(str(self.egg_path)) def _get_target(self): return self.egg_link	3.1 KB	2026-01-20 12:58
📄 script (dev).tmpl # EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r __requires__ = %(spec)r __import__('pkg_resources').require(%(spec)r) __file__ = %(dev_path)r with open(__file__) as f: exec(compile(f.read(), __file__, 'exec'))	218 B	2026-01-20 12:58
📄 script.tmpl # EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r __requires__ = %(spec)r __import__('pkg_resources').run_script(%(spec)r, %(script_name)r)	138 B	2026-01-20 12:58
📁 tests	-	2026-03-21 15:56
📄 unicode_utils.py import sys import unicodedata from configparser import RawConfigParser from .compat import py39 from .warnings import SetuptoolsDeprecationWarning # HFS Plus uses decomposed UTF-8 def decompose(path): if isinstance(path, str): return unicodedata.normalize('NFD', path) try: path = path.decode('utf-8') path = unicodedata.normalize('NFD', path) path = path.encode('utf-8') except UnicodeError: pass # Not UTF-8 return path def filesys_decode(path): """ Ensure that the given path is decoded, ``None`` when no expected encoding works """ if isinstance(path, str): return path fs_enc = sys.getfilesystemencoding() or 'utf-8' candidates = fs_enc, 'utf-8' for enc in candidates: try: return path.decode(enc) except UnicodeDecodeError: continue return None def try_encode(string, enc): "turn unicode encoding into a functional routine" try: return string.encode(enc) except UnicodeEncodeError: return None def _read_utf8_with_fallback(file: str, fallback_encoding=py39.LOCALE_ENCODING) -> str: """ First try to read the file with UTF-8, if there is an error fallback to a different encoding ("locale" by default). Returns the content of the file. Also useful when reading files that might have been produced by an older version of setuptools. """ try: with open(file, "r", encoding="utf-8") as f: return f.read() except UnicodeDecodeError: # pragma: no cover _Utf8EncodingNeeded.emit(file=file, fallback_encoding=fallback_encoding) with open(file, "r", encoding=fallback_encoding) as f: return f.read() def _cfg_read_utf8_with_fallback( cfg: RawConfigParser, file: str, fallback_encoding=py39.LOCALE_ENCODING ) -> None: """Same idea as :func:`_read_utf8_with_fallback`, but for the :meth:`RawConfigParser.read` method. This method may call ``cfg.clear()``. """ try: cfg.read(file, encoding="utf-8") except UnicodeDecodeError: # pragma: no cover _Utf8EncodingNeeded.emit(file=file, fallback_encoding=fallback_encoding) cfg.clear() cfg.read(file, encoding=fallback_encoding) class _Utf8EncodingNeeded(SetuptoolsDeprecationWarning): _SUMMARY = """ `encoding="utf-8"` fails with {file!r}, trying `encoding={fallback_encoding!r}`. """ _DETAILS = """ Fallback behavior for UTF-8 is considered deprecated and future versions of `setuptools` may not implement it. Please encode {file!r} with "utf-8" to ensure future builds will succeed. If this file was produced by `setuptools` itself, cleaning up the cached files and re-building/re-installing the package with a newer version of `setuptools` (e.g. by updating `build-system.requires` in its `pyproject.toml`) might solve the problem. """ # TODO: Add a deadline? # Will we be able to remove this? # The question comes to mind mainly because of sdists that have been produced # by old versions of setuptools and published to PyPI...	3.11 KB	2026-01-20 12:58
📄 version.py from ._importlib import metadata try: __version__ = metadata.version('setuptools') or '0.dev0+unknown' except Exception: __version__ = '0.dev0+unknown'	161 B	2026-01-20 12:58
📄 warnings.py """Provide basic warnings used by setuptools modules. Using custom classes (other than ``UserWarning``) allow users to set ``PYTHONWARNINGS`` filters to run tests and prepare for upcoming changes in setuptools. """ from __future__ import annotations import os import warnings from datetime import date from inspect import cleandoc from textwrap import indent from typing import TYPE_CHECKING if TYPE_CHECKING: from typing_extensions import TypeAlias _DueDate: TypeAlias = tuple[int, int, int] # time tuple _INDENT = 8 * " " _TEMPLATE = f"""{80 * ''}\n{{details}}\n{80 ''}""" class SetuptoolsWarning(UserWarning): """Base class in ``setuptools`` warning hierarchy.""" @classmethod def emit( cls, summary: str \| None = None, details: str \| None = None, due_date: _DueDate \| None = None, see_docs: str \| None = None, see_url: str \| None = None, stacklevel: int = 2, kwargs, ) -> None: """Private: reserved for ``setuptools`` internal use only""" # Default values: summary_ = summary or getattr(cls, "_SUMMARY", None) or "" details_ = details or getattr(cls, "_DETAILS", None) or "" due_date = due_date or getattr(cls, "_DUE_DATE", None) docs_ref = see_docs or getattr(cls, "_SEE_DOCS", None) docs_url = docs_ref and f"https://setuptools.pypa.io/en/latest/{docs_ref}" see_url = see_url or getattr(cls, "_SEE_URL", None) due = date(due_date) if due_date else None text = cls._format(summary_, details_, due, see_url or docs_url, kwargs) if due and due < date.today() and _should_enforce(): raise cls(text) warnings.warn(text, cls, stacklevel=stacklevel + 1) @classmethod def _format( cls, summary: str, details: str, due_date: date \| None = None, see_url: str \| None = None, format_args: dict \| None = None, ) -> str: """Private: reserved for ``setuptools`` internal use only""" today = date.today() summary = cleandoc(summary).format_map(format_args or {}) possible_parts = [ cleandoc(details).format_map(format_args or {}), ( f"\nBy {due_date:%Y-%b-%d}, you need to update your project and remove " "deprecated calls\nor your builds will no longer be supported." if due_date and due_date > today else None ), ( "\nThis deprecation is overdue, please update your project and remove " "deprecated\ncalls to avoid build errors in the future." if due_date and due_date < today else None ), (f"\nSee {see_url} for details." if see_url else None), ] parts = [x for x in possible_parts if x] if parts: body = indent(_TEMPLATE.format(details="\n".join(parts)), _INDENT) return "\n".join([summary, "!!\n", body, "\n!!"]) return summary class InformationOnly(SetuptoolsWarning): """Currently there is no clear way of displaying messages to the users that use the setuptools backend directly via ``pip``. The only thing that might work is a warning, although it is not the most appropriate tool for the job... See pypa/packaging-problems#558. """ class SetuptoolsDeprecationWarning(SetuptoolsWarning): """ Base class for warning deprecations in ``setuptools`` This class is not derived from ``DeprecationWarning``, and as such is visible by default. """ def _should_enforce(): enforce = os.getenv("SETUPTOOLS_ENFORCE_DEPRECATION", "false").lower() return enforce in ("true", "on", "ok", "1")	3.71 KB	2026-01-20 12:58
📄 wheel.py """Wheels support.""" import contextlib import email import functools import itertools import os import posixpath import re import zipfile from packaging.requirements import Requirement from packaging.tags import sys_tags from packaging.utils import canonicalize_name from packaging.version import Version as parse_version import setuptools from setuptools.archive_util import _unpack_zipfile_obj from setuptools.command.egg_info import _egg_basename, write_requirements from ._discovery import extras_from_deps from ._importlib import metadata from .unicode_utils import _read_utf8_with_fallback from distutils.util import get_platform WHEEL_NAME = re.compile( r"""^(?P<project_name>.+?)-(?P<version>\d.?) ((-(?P<build>\d.?))?-(?P<py_version>.+?)-(?P<abi>.+?)-(?P<platform>.+?) )\.whl$""", re.VERBOSE, ).match NAMESPACE_PACKAGE_INIT = "__import__('pkg_resources').declare_namespace(__name__)\n" @functools.cache def _get_supported_tags(): # We calculate the supported tags only once, otherwise calling # this method on thousands of wheels takes seconds instead of # milliseconds. return {(t.interpreter, t.abi, t.platform) for t in sys_tags()} def unpack(src_dir, dst_dir) -> None: """Move everything under `src_dir` to `dst_dir`, and delete the former.""" for dirpath, dirnames, filenames in os.walk(src_dir): subdir = os.path.relpath(dirpath, src_dir) for f in filenames: src = os.path.join(dirpath, f) dst = os.path.join(dst_dir, subdir, f) os.renames(src, dst) for n, d in reversed(list(enumerate(dirnames))): src = os.path.join(dirpath, d) dst = os.path.join(dst_dir, subdir, d) if not os.path.exists(dst): # Directory does not exist in destination, # rename it and prune it from os.walk list. os.renames(src, dst) del dirnames[n] # Cleanup. for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True): assert not filenames os.rmdir(dirpath) @contextlib.contextmanager def disable_info_traces(): """ Temporarily disable info traces. """ from distutils import log saved = log.set_threshold(log.WARN) try: yield finally: log.set_threshold(saved) class Wheel: def __init__(self, filename) -> None: match = WHEEL_NAME(os.path.basename(filename)) if match is None: raise ValueError(f'invalid wheel name: {filename!r}') self.filename = filename for k, v in match.groupdict().items(): setattr(self, k, v) def tags(self): """List tags (py_version, abi, platform) supported by this wheel.""" return itertools.product( self.py_version.split('.'), self.abi.split('.'), self.platform.split('.'), ) def is_compatible(self): """Is the wheel compatible with the current platform?""" return next((True for t in self.tags() if t in _get_supported_tags()), False) def egg_name(self): return ( _egg_basename( self.project_name, self.version, platform=(None if self.platform == 'any' else get_platform()), ) + ".egg" ) def get_dist_info(self, zf): # find the correct name of the .dist-info dir in the wheel file for member in zf.namelist(): dirname = posixpath.dirname(member) if dirname.endswith('.dist-info') and canonicalize_name(dirname).startswith( canonicalize_name(self.project_name) ): return dirname raise ValueError("unsupported wheel format. .dist-info not found") def install_as_egg(self, destination_eggdir) -> None: """Install wheel as an egg directory.""" with zipfile.ZipFile(self.filename) as zf: self._install_as_egg(destination_eggdir, zf) def _install_as_egg(self, destination_eggdir, zf): dist_basename = f'{self.project_name}-{self.version}' dist_info = self.get_dist_info(zf) dist_data = f'{dist_basename}.data' egg_info = os.path.join(destination_eggdir, 'EGG-INFO') self._convert_metadata(zf, destination_eggdir, dist_info, egg_info) self._move_data_entries(destination_eggdir, dist_data) self._fix_namespace_packages(egg_info, destination_eggdir) @staticmethod def _convert_metadata(zf, destination_eggdir, dist_info, egg_info): def get_metadata(name): with zf.open(posixpath.join(dist_info, name)) as fp: value = fp.read().decode('utf-8') return email.parser.Parser().parsestr(value) wheel_metadata = get_metadata('WHEEL') # Check wheel format version is supported. wheel_version = parse_version(wheel_metadata.get('Wheel-Version')) wheel_v1 = parse_version('1.0') <= wheel_version < parse_version('2.0dev0') if not wheel_v1: raise ValueError(f'unsupported wheel format version: {wheel_version}') # Extract to target directory. _unpack_zipfile_obj(zf, destination_eggdir) dist_info = os.path.join(destination_eggdir, dist_info) install_requires, extras_require = Wheel._convert_requires( destination_eggdir, dist_info ) os.rename(dist_info, egg_info) os.rename( os.path.join(egg_info, 'METADATA'), os.path.join(egg_info, 'PKG-INFO'), ) setup_dist = setuptools.Distribution( attrs=dict( install_requires=install_requires, extras_require=extras_require, ), ) with disable_info_traces(): write_requirements( setup_dist.get_command_obj('egg_info'), None, os.path.join(egg_info, 'requires.txt'), ) @staticmethod def _convert_requires(destination_eggdir, dist_info): md = metadata.Distribution.at(dist_info).metadata deps = md.get_all('Requires-Dist') or [] reqs = list(map(Requirement, deps)) extras = extras_from_deps(deps) # Note: Evaluate and strip markers now, # as it's difficult to convert back from the syntax: # foobar; "linux" in sys_platform and extra == 'test' def raw_req(req): req = Requirement(str(req)) req.marker = None return str(req) def eval(req, *env): return not req.marker or req.marker.evaluate(env) def for_extra(req): try: markers = req.marker._markers except AttributeError: markers = () return set( marker[2].value for marker in markers if isinstance(marker, tuple) and marker[0].value == 'extra' ) install_requires = list( map(raw_req, filter(eval, itertools.filterfalse(for_extra, reqs))) ) extras_require = { extra: list( map( raw_req, (req for req in reqs if for_extra(req) and eval(req, extra=extra)), ) ) for extra in extras } return install_requires, extras_require @staticmethod def _move_data_entries(destination_eggdir, dist_data): """Move data entries to their correct location.""" dist_data = os.path.join(destination_eggdir, dist_data) dist_data_scripts = os.path.join(dist_data, 'scripts') if os.path.exists(dist_data_scripts): egg_info_scripts = os.path.join(destination_eggdir, 'EGG-INFO', 'scripts') os.mkdir(egg_info_scripts) for entry in os.listdir(dist_data_scripts): # Remove bytecode, as it's not properly handled # during easy_install scripts install phase. if entry.endswith('.pyc'): os.unlink(os.path.join(dist_data_scripts, entry)) else: os.rename( os.path.join(dist_data_scripts, entry), os.path.join(egg_info_scripts, entry), ) os.rmdir(dist_data_scripts) for subdir in filter( os.path.exists, ( os.path.join(dist_data, d) for d in ('data', 'headers', 'purelib', 'platlib') ), ): unpack(subdir, destination_eggdir) if os.path.exists(dist_data): os.rmdir(dist_data) @staticmethod def _fix_namespace_packages(egg_info, destination_eggdir): namespace_packages = os.path.join(egg_info, 'namespace_packages.txt') if os.path.exists(namespace_packages): namespace_packages = _read_utf8_with_fallback(namespace_packages).split() for mod in namespace_packages: mod_dir = os.path.join(destination_eggdir, mod.split('.')) mod_init = os.path.join(mod_dir, '__init__.py') if not os.path.exists(mod_dir): os.mkdir(mod_dir) if not os.path.exists(mod_init): with open(mod_init, 'w', encoding="utf-8") as fp: fp.write(NAMESPACE_PACKAGE_INIT)	9.25 KB	2026-01-20 12:58
📄 windows_support.py import platform def windows_only(func): if platform.system() != 'Windows': return lambda args, *kwargs: None return func @windows_only def hide_file(path: str) -> None: """ Set the hidden attribute on a file or directory. From https://stackoverflow.com/questions/19622133/ `path` must be text. """ import ctypes import ctypes.wintypes SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD SetFileAttributes.restype = ctypes.wintypes.BOOL FILE_ATTRIBUTE_HIDDEN = 0x02 ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN) if not ret: raise ctypes.WinError()	726 B	2026-01-20 12:58

Edit File:

Terminal