@pyscript/core 0.5.8 → 0.5.10

package/env/lib/python3.12/site-packages/setuptools/_distutils/zosccompiler.py

@@ -1,229 +0,0 @@
-"""distutils.zosccompiler
-
-Contains the selection of the c & c++ compilers on z/OS. There are several
-different c compilers on z/OS, all of them are optional, so the correct
-one needs to be chosen based on the users input. This is compatible with
-the following compilers:
-
-IBM C/C++ For Open Enterprise Languages on z/OS 2.0
-IBM Open XL C/C++ 1.1 for z/OS
-IBM XL C/C++ V2.4.1 for z/OS 2.4 and 2.5
-IBM z/OS XL C/C++
-"""
-
-import os
-
-from . import sysconfig
-from .errors import CompileError, DistutilsExecError
-from .unixccompiler import UnixCCompiler
-
-_cc_args = {
-    'ibm-openxl': [
-        '-m64',
-        '-fvisibility=default',
-        '-fzos-le-char-mode=ascii',
-        '-fno-short-enums',
-    ],
-    'ibm-xlclang': [
-        '-q64',
-        '-qexportall',
-        '-qascii',
-        '-qstrict',
-        '-qnocsect',
-        '-Wa,asa,goff',
-        '-Wa,xplink',
-        '-qgonumber',
-        '-qenum=int',
-        '-Wc,DLL',
-    ],
-    'ibm-xlc': [
-        '-q64',
-        '-qexportall',
-        '-qascii',
-        '-qstrict',
-        '-qnocsect',
-        '-Wa,asa,goff',
-        '-Wa,xplink',
-        '-qgonumber',
-        '-qenum=int',
-        '-Wc,DLL',
-        '-qlanglvl=extc99',
-    ],
-}
-
-_cxx_args = {
-    'ibm-openxl': [
-        '-m64',
-        '-fvisibility=default',
-        '-fzos-le-char-mode=ascii',
-        '-fno-short-enums',
-    ],
-    'ibm-xlclang': [
-        '-q64',
-        '-qexportall',
-        '-qascii',
-        '-qstrict',
-        '-qnocsect',
-        '-Wa,asa,goff',
-        '-Wa,xplink',
-        '-qgonumber',
-        '-qenum=int',
-        '-Wc,DLL',
-    ],
-    'ibm-xlc': [
-        '-q64',
-        '-qexportall',
-        '-qascii',
-        '-qstrict',
-        '-qnocsect',
-        '-Wa,asa,goff',
-        '-Wa,xplink',
-        '-qgonumber',
-        '-qenum=int',
-        '-Wc,DLL',
-        '-qlanglvl=extended0x',
-    ],
-}
-
-_asm_args = {
-    'ibm-openxl': ['-fasm', '-fno-integrated-as', '-Wa,--ASA', '-Wa,--GOFF'],
-    'ibm-xlclang': [],
-    'ibm-xlc': [],
-}
-
-_ld_args = {
-    'ibm-openxl': [],
-    'ibm-xlclang': ['-Wl,dll', '-q64'],
-    'ibm-xlc': ['-Wl,dll', '-q64'],
-}
-
-
-# Python on z/OS is built with no compiler specific options in it's CFLAGS.
-# But each compiler requires it's own specific options to build successfully,
-# though some of the options are common between them
-class zOSCCompiler(UnixCCompiler):
-    src_extensions = ['.c', '.C', '.cc', '.cxx', '.cpp', '.m', '.s']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx', '.C']
-    _asm_extensions = ['.s']
-
-    def _get_zos_compiler_name(self):
-        zos_compiler_names = [
-            os.path.basename(binary)
-            for envvar in ('CC', 'CXX', 'LDSHARED')
-            if (binary := os.environ.get(envvar, None))
-        ]
-        if len(zos_compiler_names) == 0:
-            return 'ibm-openxl'
-
-        zos_compilers = {}
-        for compiler in (
-            'ibm-clang',
-            'ibm-clang64',
-            'ibm-clang++',
-            'ibm-clang++64',
-            'clang',
-            'clang++',
-            'clang-14',
-        ):
-            zos_compilers[compiler] = 'ibm-openxl'
-
-        for compiler in ('xlclang', 'xlclang++', 'njsc', 'njsc++'):
-            zos_compilers[compiler] = 'ibm-xlclang'
-
-        for compiler in ('xlc', 'xlC', 'xlc++'):
-            zos_compilers[compiler] = 'ibm-xlc'
-
-        return zos_compilers.get(zos_compiler_names[0], 'ibm-openxl')
-
-    def __init__(self, verbose=False, dry_run=False, force=False):
-        super().__init__(verbose, dry_run, force)
-        self.zos_compiler = self._get_zos_compiler_name()
-        sysconfig.customize_compiler(self)
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        local_args = []
-        if ext in self._cpp_extensions:
-            compiler = self.compiler_cxx
-            local_args.extend(_cxx_args[self.zos_compiler])
-        elif ext in self._asm_extensions:
-            compiler = self.compiler_so
-            local_args.extend(_cc_args[self.zos_compiler])
-            local_args.extend(_asm_args[self.zos_compiler])
-        else:
-            compiler = self.compiler_so
-            local_args.extend(_cc_args[self.zos_compiler])
-        local_args.extend(cc_args)
-
-        try:
-            self.spawn(compiler + local_args + [src, '-o', obj] + extra_postargs)
-        except DistutilsExecError as msg:
-            raise CompileError(msg)
-
-    def runtime_library_dir_option(self, dir):
-        return '-L' + dir
-
-    def link(
-        self,
-        target_desc,
-        objects,
-        output_filename,
-        output_dir=None,
-        libraries=None,
-        library_dirs=None,
-        runtime_library_dirs=None,
-        export_symbols=None,
-        debug=False,
-        extra_preargs=None,
-        extra_postargs=None,
-        build_temp=None,
-        target_lang=None,
-    ):
-        # For a built module to use functions from cpython, it needs to use Pythons
-        # side deck file. The side deck is located beside the libpython3.xx.so
-        ldversion = sysconfig.get_config_var('LDVERSION')
-        if sysconfig.python_build:
-            side_deck_path = os.path.join(
-                sysconfig.get_config_var('abs_builddir'),
-                f'libpython{ldversion}.x',
-            )
-        else:
-            side_deck_path = os.path.join(
-                sysconfig.get_config_var('installed_base'),
-                sysconfig.get_config_var('platlibdir'),
-                f'libpython{ldversion}.x',
-            )
-
-        if os.path.exists(side_deck_path):
-            if extra_postargs:
-                extra_postargs.append(side_deck_path)
-            else:
-                extra_postargs = [side_deck_path]
-
-        # Check and replace libraries included side deck files
-        if runtime_library_dirs:
-            for dir in runtime_library_dirs:
-                for library in libraries[:]:
-                    library_side_deck = os.path.join(dir, f'{library}.x')
-                    if os.path.exists(library_side_deck):
-                        libraries.remove(library)
-                        extra_postargs.append(library_side_deck)
-                        break
-
-        # Any required ld args for the given compiler
-        extra_postargs.extend(_ld_args[self.zos_compiler])
-
-        super().link(
-            target_desc,
-            objects,
-            output_filename,
-            output_dir,
-            libraries,
-            library_dirs,
-            runtime_library_dirs,
-            export_symbols,
-            debug,
-            extra_preargs,
-            extra_postargs,
-            build_temp,
-            target_lang,
-        )

package/env/lib/python3.12/site-packages/setuptools/_entry_points.py

@@ -1,90 +0,0 @@
-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.
-    """
-    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))

package/env/lib/python3.12/site-packages/setuptools/_imp.py

@@ -1,87 +0,0 @@
-"""
-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("Can't find %s" % 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("Can't find %s" % module)
-    return spec.loader.get_code(module)
-
-
-def get_module(module, paths, info):
-    spec = find_spec(module, paths)
-    if not spec:
-        raise ImportError("Can't find %s" % module)
-    return module_from_spec(spec)

package/env/lib/python3.12/site-packages/setuptools/_importlib.py

@@ -1,12 +0,0 @@
-import sys
-
-if sys.version_info < (3, 10):
-    import importlib_metadata as metadata  # pragma: no cover
-else:
-    import importlib.metadata as metadata  # noqa: F401
-
-
-if sys.version_info < (3, 9):
-    import importlib_resources as resources  # pragma: no cover
-else:
-    import importlib.resources as resources  # noqa: F401

package/env/lib/python3.12/site-packages/setuptools/_itertools.py

@@ -1,23 +0,0 @@
-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

package/env/lib/python3.12/site-packages/setuptools/_normalization.py

@@ -1,144 +0,0 @@
-"""
-Helpers for normalization as expected in wheel/sdist/module file names
-and core metadata
-"""
-
-import re
-
-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'
-    """
-    # See pkg_resources.safe_name
-    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'
-    """
-    # See pkg_resources._forgiving_version
-    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 filename_component(safe_name(value))
-
-
-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))

package/env/lib/python3.12/site-packages/setuptools/_path.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import os
-import sys
-from typing import TYPE_CHECKING, Union
-
-if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
-
-
-from more_itertools import unique_everseen
-
-if sys.version_info >= (3, 9):
-    StrPath: TypeAlias = Union[str, os.PathLike[str]]  #  Same as _typeshed.StrPath
-else:
-    StrPath: TypeAlias = Union[str, os.PathLike]
-
-
-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 normpath(filename: StrPath) -> str:
-    """Normalize a file/dir name for comparison purposes."""
-    # See pkg_resources.normalize_path for notes about cygwin
-    file = os.path.abspath(filename) if sys.platform == 'cygwin' else filename
-    return os.path.normcase(os.path.realpath(os.path.normpath(file)))
-
-
-@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