@pyscript/core 0.5.8 → 0.5.9

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

@@ -1,286 +0,0 @@
-"""
-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 .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.1')
-        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.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("%s: %s\n" % (key, value))
-
-    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)
-
-    license = self.get_license()
-    if license:
-        write_field('License', rfc822_escape(license))
-
-    for project_url in self.project_urls.items():
-        write_field('Project-URL', '%s, %s' % project_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)
-
-    self._write_list(file, 'License-File', self.license_files or [])
-    _write_requirements(self, file)
-
-    long_description = self.get_long_description()
-    if long_description:
-        file.write("\n%s" % 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),
-    )

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

@@ -1,14 +0,0 @@
-import importlib
-import sys
-
-__version__, _, _ = sys.version.partition(' ')
-
-
-try:
-    # Allow Debian and pkgsrc (only) to customize system
-    # behavior. Ref pypa/distutils#2 and pypa/distutils#16.
-    # This hook is deprecated and no other environments
-    # should use it.
-    importlib.import_module('_distutils_system_mod')
-except ImportError:
-    pass

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

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-import collections
-import itertools
-
-
-# from jaraco.collections 3.5.1
-class DictStack(list, collections.abc.Mapping):
-    """
-    A stack of dictionaries that behaves as a view on those dictionaries,
-    giving preference to the last.
-
-    >>> stack = DictStack([dict(a=1, c=2), dict(b=2, a=2)])
-    >>> stack['a']
-    2
-    >>> stack['b']
-    2
-    >>> stack['c']
-    2
-    >>> len(stack)
-    3
-    >>> stack.push(dict(a=3))
-    >>> stack['a']
-    3
-    >>> set(stack.keys()) == set(['a', 'b', 'c'])
-    True
-    >>> set(stack.items()) == set([('a', 3), ('b', 2), ('c', 2)])
-    True
-    >>> dict(**stack) == dict(stack) == dict(a=3, c=2, b=2)
-    True
-    >>> d = stack.pop()
-    >>> stack['a']
-    2
-    >>> d = stack.pop()
-    >>> stack['a']
-    1
-    >>> stack.get('b', None)
-    >>> 'c' in stack
-    True
-    """
-
-    def __iter__(self):
-        dicts = list.__iter__(self)
-        return iter(set(itertools.chain.from_iterable(c.keys() for c in dicts)))
-
-    def __getitem__(self, key):
-        for scope in reversed(tuple(list.__iter__(self))):
-            if key in scope:
-                return scope[key]
-        raise KeyError(key)
-
-    push = list.append
-
-    def __contains__(self, other):
-        return collections.abc.Mapping.__contains__(self, other)
-
-    def __len__(self):
-        return len(list(iter(self)))

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

@@ -1,73 +0,0 @@
-import collections.abc
-import functools
-
-
-# from jaraco.functools 3.5
-def pass_none(func):
-    """
-    Wrap func so it's not called if its first param is None
-
-    >>> print_text = pass_none(print)
-    >>> print_text('text')
-    text
-    >>> print_text(None)
-    """
-
-    @functools.wraps(func)
-    def wrapper(param, *args, **kwargs):
-        if param is not None:
-            return func(param, *args, **kwargs)
-
-    return wrapper
-
-
-# from jaraco.functools 4.0
-@functools.singledispatch
-def _splat_inner(args, func):
-    """Splat args to func."""
-    return func(*args)
-
-
-@_splat_inner.register
-def _(args: collections.abc.Mapping, func):
-    """Splat kargs to func as kwargs."""
-    return func(**args)
-
-
-def splat(func):
-    """
-    Wrap func to expect its parameters to be passed positionally in a tuple.
-
-    Has a similar effect to that of ``itertools.starmap`` over
-    simple ``map``.
-
-    >>> import itertools, operator
-    >>> pairs = [(-1, 1), (0, 2)]
-    >>> _ = tuple(itertools.starmap(print, pairs))
-    -1 1
-    0 2
-    >>> _ = tuple(map(splat(print), pairs))
-    -1 1
-    0 2
-
-    The approach generalizes to other iterators that don't have a "star"
-    equivalent, such as a "starfilter".
-
-    >>> list(filter(splat(operator.add), pairs))
-    [(0, 2)]
-
-    Splat also accepts a mapping argument.
-
-    >>> def is_nice(msg, code):
-    ...     return "smile" in msg or code == 0
-    >>> msgs = [
-    ...     dict(msg='smile!', code=20),
-    ...     dict(msg='error :(', code=1),
-    ...     dict(msg='unknown', code=0),
-    ... ]
-    >>> for msg in filter(splat(is_nice), msgs):
-    ...     print(msg)
-    {'msg': 'smile!', 'code': 20}
-    {'msg': 'unknown', 'code': 0}
-    """
-    return functools.wraps(func)(functools.partial(_splat_inner, func=func))

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

@@ -1,52 +0,0 @@
-# from more_itertools 10.2
-def always_iterable(obj, base_type=(str, bytes)):
-    """If *obj* is iterable, return an iterator over its items::
-
-        >>> obj = (1, 2, 3)
-        >>> list(always_iterable(obj))
-        [1, 2, 3]
-
-    If *obj* is not iterable, return a one-item iterable containing *obj*::
-
-        >>> obj = 1
-        >>> list(always_iterable(obj))
-        [1]
-
-    If *obj* is ``None``, return an empty iterable:
-
-        >>> obj = None
-        >>> list(always_iterable(None))
-        []
-
-    By default, binary and text strings are not considered iterable::
-
-        >>> obj = 'foo'
-        >>> list(always_iterable(obj))
-        ['foo']
-
-    If *base_type* is set, objects for which ``isinstance(obj, base_type)``
-    returns ``True`` won't be considered iterable.
-
-        >>> obj = {'a': 1}
-        >>> list(always_iterable(obj))  # Iterate over the dict's keys
-        ['a']
-        >>> list(always_iterable(obj, base_type=dict))  # Treat dicts as a unit
-        [{'a': 1}]
-
-    Set *base_type* to ``None`` to avoid any special handling and treat objects
-    Python considers iterable as iterable:
-
-        >>> obj = 'foo'
-        >>> list(always_iterable(obj, base_type=None))
-        ['f', 'o', 'o']
-    """
-    if obj is None:
-        return iter(())
-
-    if (base_type is not None) and isinstance(obj, base_type):
-        return iter((obj,))
-
-    try:
-        return iter(obj)
-    except TypeError:
-        return iter((obj,))

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

@@ -1,3 +0,0 @@
-import logging
-
-log = logging.getLogger()

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

@@ -1,12 +0,0 @@
-import importlib
-import sys
-
-
-def bypass_compiler_fixup(cmd, args):
-    return cmd
-
-
-if sys.platform == 'darwin':
-    compiler_fixup = importlib.import_module('_osx_support').compiler_fixup
-else:
-    compiler_fixup = bypass_compiler_fixup

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

@@ -1,72 +0,0 @@
-"""Timestamp comparison of files and groups of files."""
-
-import functools
-import os.path
-
-from ._functools import splat
-from .compat.py39 import zip_strict
-from .errors import DistutilsFileError
-
-
-def _newer(source, target):
-    return not os.path.exists(target) or (
-        os.path.getmtime(source) > os.path.getmtime(target)
-    )
-
-
-def newer(source, target):
-    """
-    Is source modified more recently than target.
-
-    Returns True if 'source' is modified more recently than
-    'target' or if 'target' does not exist.
-
-    Raises DistutilsFileError if 'source' does not exist.
-    """
-    if not os.path.exists(source):
-        raise DistutilsFileError(f"file '{os.path.abspath(source)}' does not exist")
-
-    return _newer(source, target)
-
-
-def newer_pairwise(sources, targets, newer=newer):
-    """
-    Filter filenames where sources are newer than targets.
-
-    Walk two filename iterables in parallel, testing if each source is newer
-    than its corresponding target.  Returns a pair of lists (sources,
-    targets) where source is newer than target, according to the semantics
-    of 'newer()'.
-    """
-    newer_pairs = filter(splat(newer), zip_strict(sources, targets))
-    return tuple(map(list, zip(*newer_pairs))) or ([], [])
-
-
-def newer_group(sources, target, missing='error'):
-    """
-    Is target out-of-date with respect to any file in sources.
-
-    Return True if 'target' is out-of-date with respect to any file
-    listed in 'sources'. In other words, if 'target' exists and is newer
-    than every file in 'sources', return False; otherwise return True.
-    ``missing`` controls how to handle a missing source file:
-
-    - error (default): allow the ``stat()`` call to fail.
-    - ignore: silently disregard any missing source files.
-    - newer: treat missing source files as "target out of date". This
-      mode is handy in "dry-run" mode: it will pretend to carry out
-      commands that wouldn't work because inputs are missing, but
-      that doesn't matter because dry-run won't run the commands.
-    """
-
-    def missing_as_newer(source):
-        return missing == 'newer' and not os.path.exists(source)
-
-    ignored = os.path.exists if missing == 'ignore' else None
-    return not os.path.exists(target) or any(
-        missing_as_newer(source) or _newer(source, target)
-        for source in filter(ignored, sources)
-    )
-
-
-newer_pairwise_group = functools.partial(newer_pairwise, newer=newer_group)