@pyscript/core 0.5.5 → 0.5.6

package/env/lib/python3.12/site-packages/pkg_resources/api_tests.txt

@@ -0,0 +1,424 @@
+Pluggable Distributions of Python Software
+==========================================
+
+Distributions
+-------------
+
+A "Distribution" is a collection of files that represent a "Release" of a
+"Project" as of a particular point in time, denoted by a
+"Version"::
+
+    >>> import sys, pkg_resources
+    >>> from pkg_resources import Distribution
+    >>> Distribution(project_name="Foo", version="1.2")
+    Foo 1.2
+
+Distributions have a location, which can be a filename, URL, or really anything
+else you care to use::
+
+    >>> dist = Distribution(
+    ...     location="http://example.com/something",
+    ...     project_name="Bar", version="0.9"
+    ... )
+
+    >>> dist
+    Bar 0.9 (http://example.com/something)
+
+
+Distributions have various introspectable attributes::
+
+    >>> dist.location
+    'http://example.com/something'
+
+    >>> dist.project_name
+    'Bar'
+
+    >>> dist.version
+    '0.9'
+
+    >>> dist.py_version == '{}.{}'.format(*sys.version_info)
+    True
+
+    >>> print(dist.platform)
+    None
+
+Including various computed attributes::
+
+    >>> from pkg_resources import parse_version
+    >>> dist.parsed_version == parse_version(dist.version)
+    True
+
+    >>> dist.key    # case-insensitive form of the project name
+    'bar'
+
+Distributions are compared (and hashed) by version first::
+
+    >>> Distribution(version='1.0') == Distribution(version='1.0')
+    True
+    >>> Distribution(version='1.0') == Distribution(version='1.1')
+    False
+    >>> Distribution(version='1.0') <  Distribution(version='1.1')
+    True
+
+but also by project name (case-insensitive), platform, Python version,
+location, etc.::
+
+    >>> Distribution(project_name="Foo",version="1.0") == \
+    ... Distribution(project_name="Foo",version="1.0")
+    True
+
+    >>> Distribution(project_name="Foo",version="1.0") == \
+    ... Distribution(project_name="foo",version="1.0")
+    True
+
+    >>> Distribution(project_name="Foo",version="1.0") == \
+    ... Distribution(project_name="Foo",version="1.1")
+    False
+
+    >>> Distribution(project_name="Foo",py_version="2.3",version="1.0") == \
+    ... Distribution(project_name="Foo",py_version="2.4",version="1.0")
+    False
+
+    >>> Distribution(location="spam",version="1.0") == \
+    ... Distribution(location="spam",version="1.0")
+    True
+
+    >>> Distribution(location="spam",version="1.0") == \
+    ... Distribution(location="baz",version="1.0")
+    False
+
+
+
+Hash and compare distribution by prio/plat
+
+Get version from metadata
+provider capabilities
+egg_name()
+as_requirement()
+from_location, from_filename (w/path normalization)
+
+Releases may have zero or more "Requirements", which indicate
+what releases of another project the release requires in order to
+function.  A Requirement names the other project, expresses some criteria
+as to what releases of that project are acceptable, and lists any "Extras"
+that the requiring release may need from that project.  (An Extra is an
+optional feature of a Release, that can only be used if its additional
+Requirements are satisfied.)
+
+
+
+The Working Set
+---------------
+
+A collection of active distributions is called a Working Set.  Note that a
+Working Set can contain any importable distribution, not just pluggable ones.
+For example, the Python standard library is an importable distribution that
+will usually be part of the Working Set, even though it is not pluggable.
+Similarly, when you are doing development work on a project, the files you are
+editing are also a Distribution.  (And, with a little attention to the
+directory names used,  and including some additional metadata, such a
+"development distribution" can be made pluggable as well.)
+
+    >>> from pkg_resources import WorkingSet
+
+A working set's entries are the sys.path entries that correspond to the active
+distributions.  By default, the working set's entries are the items on
+``sys.path``::
+
+    >>> ws = WorkingSet()
+    >>> ws.entries == sys.path
+    True
+
+But you can also create an empty working set explicitly, and add distributions
+to it::
+
+    >>> ws = WorkingSet([])
+    >>> ws.add(dist)
+    >>> ws.entries
+    ['http://example.com/something']
+    >>> dist in ws
+    True
+    >>> Distribution('foo',version="") in ws
+    False
+
+And you can iterate over its distributions::
+
+    >>> list(ws)
+    [Bar 0.9 (http://example.com/something)]
+
+Adding the same distribution more than once is a no-op::
+
+    >>> ws.add(dist)
+    >>> list(ws)
+    [Bar 0.9 (http://example.com/something)]
+
+For that matter, adding multiple distributions for the same project also does
+nothing, because a working set can only hold one active distribution per
+project -- the first one added to it::
+
+    >>> ws.add(
+    ...     Distribution(
+    ...         'http://example.com/something', project_name="Bar",
+    ...         version="7.2"
+    ...     )
+    ... )
+    >>> list(ws)
+    [Bar 0.9 (http://example.com/something)]
+
+You can append a path entry to a working set using ``add_entry()``::
+
+    >>> ws.entries
+    ['http://example.com/something']
+    >>> ws.add_entry(pkg_resources.__file__)
+    >>> ws.entries
+    ['http://example.com/something', '...pkg_resources...']
+
+Multiple additions result in multiple entries, even if the entry is already in
+the working set (because ``sys.path`` can contain the same entry more than
+once)::
+
+    >>> ws.add_entry(pkg_resources.__file__)
+    >>> ws.entries
+    ['...example.com...', '...pkg_resources...', '...pkg_resources...']
+
+And you can specify the path entry a distribution was found under, using the
+optional second parameter to ``add()``::
+
+    >>> ws = WorkingSet([])
+    >>> ws.add(dist,"foo")
+    >>> ws.entries
+    ['foo']
+
+But even if a distribution is found under multiple path entries, it still only
+shows up once when iterating the working set:
+
+    >>> ws.add_entry(ws.entries[0])
+    >>> list(ws)
+    [Bar 0.9 (http://example.com/something)]
+
+You can ask a WorkingSet to ``find()`` a distribution matching a requirement::
+
+    >>> from pkg_resources import Requirement
+    >>> print(ws.find(Requirement.parse("Foo==1.0")))   # no match, return None
+    None
+
+    >>> ws.find(Requirement.parse("Bar==0.9"))  # match, return distribution
+    Bar 0.9 (http://example.com/something)
+
+Note that asking for a conflicting version of a distribution already in a
+working set triggers a ``pkg_resources.VersionConflict`` error:
+
+    >>> try:
+    ...     ws.find(Requirement.parse("Bar==1.0"))
+    ... except pkg_resources.VersionConflict as exc:
+    ...     print(str(exc))
+    ... else:
+    ...     raise AssertionError("VersionConflict was not raised")
+    (Bar 0.9 (http://example.com/something), Requirement.parse('Bar==1.0'))
+
+You can subscribe a callback function to receive notifications whenever a new
+distribution is added to a working set.  The callback is immediately invoked
+once for each existing distribution in the working set, and then is called
+again for new distributions added thereafter::
+
+    >>> def added(dist): print("Added %s" % dist)
+    >>> ws.subscribe(added)
+    Added Bar 0.9
+    >>> foo12 = Distribution(project_name="Foo", version="1.2", location="f12")
+    >>> ws.add(foo12)
+    Added Foo 1.2
+
+Note, however, that only the first distribution added for a given project name
+will trigger a callback, even during the initial ``subscribe()`` callback::
+
+    >>> foo14 = Distribution(project_name="Foo", version="1.4", location="f14")
+    >>> ws.add(foo14)   # no callback, because Foo 1.2 is already active
+
+    >>> ws = WorkingSet([])
+    >>> ws.add(foo12)
+    >>> ws.add(foo14)
+    >>> ws.subscribe(added)
+    Added Foo 1.2
+
+And adding a callback more than once has no effect, either::
+
+    >>> ws.subscribe(added)     # no callbacks
+
+    # and no double-callbacks on subsequent additions, either
+    >>> just_a_test = Distribution(project_name="JustATest", version="0.99")
+    >>> ws.add(just_a_test)
+    Added JustATest 0.99
+
+
+Finding Plugins
+---------------
+
+``WorkingSet`` objects can be used to figure out what plugins in an
+``Environment`` can be loaded without any resolution errors::
+
+    >>> from pkg_resources import Environment
+
+    >>> plugins = Environment([])   # normally, a list of plugin directories
+    >>> plugins.add(foo12)
+    >>> plugins.add(foo14)
+    >>> plugins.add(just_a_test)
+
+In the simplest case, we just get the newest version of each distribution in
+the plugin environment::
+
+    >>> ws = WorkingSet([])
+    >>> ws.find_plugins(plugins)
+    ([JustATest 0.99, Foo 1.4 (f14)], {})
+
+But if there's a problem with a version conflict or missing requirements, the
+method falls back to older versions, and the error info dict will contain an
+exception instance for each unloadable plugin::
+
+    >>> ws.add(foo12)   # this will conflict with Foo 1.4
+    >>> ws.find_plugins(plugins)
+    ([JustATest 0.99, Foo 1.2 (f12)], {Foo 1.4 (f14): VersionConflict(...)})
+
+But if you disallow fallbacks, the failed plugin will be skipped instead of
+trying older versions::
+
+    >>> ws.find_plugins(plugins, fallback=False)
+    ([JustATest 0.99], {Foo 1.4 (f14): VersionConflict(...)})
+
+
+
+Platform Compatibility Rules
+----------------------------
+
+On the Mac, there are potential compatibility issues for modules compiled
+on newer versions of macOS than what the user is running. Additionally,
+macOS will soon have two platforms to contend with: Intel and PowerPC.
+
+Basic equality works as on other platforms::
+
+    >>> from pkg_resources import compatible_platforms as cp
+    >>> reqd = 'macosx-10.4-ppc'
+    >>> cp(reqd, reqd)
+    True
+    >>> cp("win32", reqd)
+    False
+
+Distributions made on other machine types are not compatible::
+
+    >>> cp("macosx-10.4-i386", reqd)
+    False
+
+Distributions made on earlier versions of the OS are compatible, as
+long as they are from the same top-level version. The patchlevel version
+number does not matter::
+
+    >>> cp("macosx-10.4-ppc", reqd)
+    True
+    >>> cp("macosx-10.3-ppc", reqd)
+    True
+    >>> cp("macosx-10.5-ppc", reqd)
+    False
+    >>> cp("macosx-9.5-ppc", reqd)
+    False
+
+Backwards compatibility for packages made via earlier versions of
+setuptools is provided as well::
+
+    >>> cp("darwin-8.2.0-Power_Macintosh", reqd)
+    True
+    >>> cp("darwin-7.2.0-Power_Macintosh", reqd)
+    True
+    >>> cp("darwin-8.2.0-Power_Macintosh", "macosx-10.3-ppc")
+    False
+
+
+Environment Markers
+-------------------
+
+    >>> from pkg_resources import invalid_marker as im, evaluate_marker as em
+    >>> import os
+
+    >>> print(im("sys_platform"))
+    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
+        sys_platform
+                    ^
+
+    >>> print(im("sys_platform=="))
+    Expected a marker variable or quoted string
+        sys_platform==
+                      ^
+
+    >>> print(im("sys_platform=='win32'"))
+    False
+
+    >>> print(im("sys=='x'"))
+    Expected a marker variable or quoted string
+        sys=='x'
+        ^
+
+    >>> print(im("(extra)"))
+    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
+        (extra)
+              ^
+
+    >>> print(im("(extra"))
+    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
+        (extra
+              ^
+
+    >>> print(im("os.open('foo')=='y'"))
+    Expected a marker variable or quoted string
+        os.open('foo')=='y'
+        ^
+
+    >>> print(im("'x'=='y' and os.open('foo')=='y'"))   # no short-circuit!
+    Expected a marker variable or quoted string
+        'x'=='y' and os.open('foo')=='y'
+                     ^
+
+    >>> print(im("'x'=='x' or os.open('foo')=='y'"))   # no short-circuit!
+    Expected a marker variable or quoted string
+        'x'=='x' or os.open('foo')=='y'
+                    ^
+
+    >>> print(im("r'x'=='x'"))
+    Expected a marker variable or quoted string
+        r'x'=='x'
+        ^
+
+    >>> print(im("'''x'''=='x'"))
+    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
+        '''x'''=='x'
+          ^
+
+    >>> print(im('"""x"""=="x"'))
+    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
+        """x"""=="x"
+          ^
+
+    >>> print(im(r"x\n=='x'"))
+    Expected a marker variable or quoted string
+        x\n=='x'
+        ^
+
+    >>> print(im("os.open=='y'"))
+    Expected a marker variable or quoted string
+        os.open=='y'
+        ^
+
+    >>> em("sys_platform=='win32'") == (sys.platform=='win32')
+    True
+
+    >>> em("python_version >= '2.7'")
+    True
+
+    >>> em("python_version > '2.6'")
+    True
+
+    >>> im("implementation_name=='cpython'")
+    False
+
+    >>> im("platform_python_implementation=='CPython'")
+    False
+
+    >>> im("implementation_version=='3.5.1'")
+    False

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

@@ -0,0 +1,231 @@
+"""
+This package transforms python source code strings or ast.Module Nodes into
+a 'minified' representation of the same source code.
+
+"""
+
+import ast
+import re
+
+from python_minifier.ast_compare import CompareError, compare_ast
+from python_minifier.module_printer import ModulePrinter
+from python_minifier.rename import (
+    rename_literals,
+    bind_names,
+    resolve_names,
+    rename,
+    allow_rename_globals,
+    allow_rename_locals,
+    add_namespace,
+)
+
+from python_minifier.transforms.combine_imports import CombineImports
+from python_minifier.transforms.remove_annotations import RemoveAnnotations
+from python_minifier.transforms.remove_asserts import RemoveAsserts
+from python_minifier.transforms.remove_debug import RemoveDebug
+from python_minifier.transforms.remove_explicit_return_none import RemoveExplicitReturnNone
+from python_minifier.transforms.remove_literal_statements import RemoveLiteralStatements
+from python_minifier.transforms.remove_object_base import RemoveObject
+from python_minifier.transforms.remove_pass import RemovePass
+from python_minifier.transforms.remove_posargs import remove_posargs
+
+
+class UnstableMinification(RuntimeError):
+    """
+    Raised when a minified module differs from the original module in an unexpected way.
+
+    This is raised when the minifier generates source code that doesn't parse back into the
+    original module (after known transformations).
+    This should never occur and is a bug.
+
+    """
+
+    def __init__(self, exception, source, minified):
+        self.exception = exception
+        self.source = source
+        self.minified = minified
+
+    def __str__(self):
+        return 'Minification was unstable! Please create an issue at https://github.com/dflook/python-minifier/issues'
+
+
+def minify(
+    source,
+    filename=None,
+    remove_annotations=True,
+    remove_pass=True,
+    remove_literal_statements=False,
+    combine_imports=True,
+    hoist_literals=True,
+    rename_locals=True,
+    preserve_locals=None,
+    rename_globals=False,
+    preserve_globals=None,
+    remove_object_base=True,
+    convert_posargs_to_args=True,
+    preserve_shebang=True,
+    remove_asserts=False,
+    remove_debug=False,
+    remove_explicit_return_none=True,
+):
+    """
+    Minify a python module
+
+    The module is transformed according the the arguments.
+    If all transformation arguments are False, no transformations are made to the AST, the returned string will
+    parse into exactly the same module.
+
+    Using the default arguments only transformations that are always or almost always safe are enabled.
+
+    :param str source: The python module source code
+    :param str filename: The original source filename if known
+
+    :param bool remove_annotations: If type annotations should be removed where possible
+    :param bool remove_pass: If Pass statements should be removed where possible
+    :param bool remove_literal_statements: If statements consisting of a single literal should be removed, including docstrings
+    :param bool combine_imports: Combine adjacent import statements where possible
+    :param bool hoist_literals: If str and byte literals may be hoisted to the module level where possible.
+    :param bool rename_locals: If local names may be shortened
+    :param preserve_locals: Locals names to leave unchanged when rename_locals is True
+    :type preserve_locals: list[str]
+    :param bool rename_globals: If global names may be shortened
+    :param preserve_globals: Global names to leave unchanged when rename_globals is True
+    :type preserve_globals: list[str]
+    :param bool remove_object_base: If object as a base class may be removed
+    :param bool convert_posargs_to_args: If positional-only arguments will be converted to normal arguments
+    :param bool preserve_shebang: Keep any shebang interpreter directive from the source in the minified output
+    :param bool remove_asserts: If assert statements should be removed
+    :param bool remove_debug: If conditional statements that test '__debug__ is True' should be removed
+    :param bool remove_explicit_return_none: If explicit return None statements should be replaced with a bare return
+
+    :rtype: str
+
+    """
+
+    filename = filename or 'python_minifier.minify source'
+
+    # This will raise if the source file can't be parsed
+    module = ast.parse(source, filename)
+
+    add_namespace(module)
+
+    if remove_literal_statements:
+        module = RemoveLiteralStatements()(module)
+
+    if combine_imports:
+        module = CombineImports()(module)
+
+    if remove_annotations:
+        module = RemoveAnnotations()(module)
+
+    if remove_pass:
+        module = RemovePass()(module)
+
+    if remove_object_base:
+        module = RemoveObject()(module)
+
+    if remove_asserts:
+        module = RemoveAsserts()(module)
+
+    if remove_debug:
+        module = RemoveDebug()(module)
+
+    if remove_explicit_return_none:
+        module = RemoveExplicitReturnNone()(module)
+
+    bind_names(module)
+    resolve_names(module)
+
+    if module.tainted:
+        rename_globals = False
+        rename_locals = False
+
+    allow_rename_locals(module, rename_locals, preserve_locals)
+    allow_rename_globals(module, rename_globals, preserve_globals)
+
+    if hoist_literals:
+        rename_literals(module)
+
+    rename(module, prefix_globals=not rename_globals, preserved_globals=preserve_globals)
+
+    if convert_posargs_to_args:
+        module = remove_posargs(module)
+
+    minified = unparse(module)
+
+    if preserve_shebang is True:
+        shebang_line = _find_shebang(source)
+        if shebang_line is not None:
+            return shebang_line + '\n' + minified
+
+    return minified
+
+def _find_shebang(source):
+    """
+    Find a shebang line in source
+    """
+
+    if isinstance(source, bytes):
+        shebang = re.match(br'^#!.*', source)
+        if shebang:
+            return shebang.group().decode()
+    else:
+        shebang = re.match(r'^#!.*', source)
+        if shebang:
+            return shebang.group()
+
+    return None
+
+def unparse(module):
+    """
+    Turn a module AST into python code
+
+    This returns an exact representation of the given module,
+    such that it can be parsed back into the same AST.
+
+    :param module: The module to turn into python code
+    :type: module: :class:`ast.Module`
+    :rtype: str
+
+    """
+
+    assert isinstance(module, ast.Module)
+
+    printer = ModulePrinter()
+    printer(module)
+
+    try:
+        minified_module = ast.parse(printer.code, 'python_minifier.unparse output')
+    except SyntaxError as syntax_error:
+        raise UnstableMinification(syntax_error, '', printer.code)
+
+    try:
+        compare_ast(module, minified_module)
+    except CompareError as compare_error:
+        raise UnstableMinification(compare_error, '', printer.code)
+
+    return printer.code
+
+
+def awslambda(source, filename=None, entrypoint=None):
+    """
+    Minify a python module for use as an AWS Lambda function
+
+    This returns a string suitable for embedding in a cloudformation template.
+    When minifying, all transformations are enabled.
+
+    :param str source: The python module source code
+    :param str filename: The original source filename if known
+    :param entrypoint: The lambda entrypoint function
+    :type entrypoint: str or NoneType
+    :rtype: str
+
+    """
+
+    rename_globals = True
+    if entrypoint is None:
+        rename_globals = False
+
+    return minify(
+        source, filename, remove_literal_statements=True, rename_globals=rename_globals, preserve_globals=[entrypoint],
+    )

package/env/lib/python3.12/site-packages/python_minifier/__init__.pyi

@@ -0,0 +1,34 @@
+import ast
+from typing import List, Text, AnyStr, Optional, Any
+
+
+class UnstableMinification(RuntimeError):
+    def __init__(self, exception: Any, source: Any, minified: Any): ...
+
+def minify(
+    source: AnyStr,
+    filename: Optional[str] = ...,
+    remove_annotations: bool = ...,
+    remove_pass: bool = ...,
+    remove_literal_statements: bool = ...,
+    combine_imports: bool = ...,
+    hoist_literals: bool = ...,
+    rename_locals: bool = ...,
+    preserve_locals: Optional[List[Text]] = ...,
+    rename_globals: bool = ...,
+    preserve_globals: Optional[List[Text]] = ...,
+    remove_object_base: bool = ...,
+    convert_posargs_to_args: bool = ...,
+    preserve_shebang: bool = ...,
+    remove_asserts: bool = ...,
+    remove_debug: bool = ...,
+    remove_explicit_return_none: bool = ...
+) -> Text: ...
+
+def unparse(module: ast.Module) -> Text: ...
+
+def awslambda(
+    source: AnyStr,
+    filename: Optional[Text] = ...,
+    entrypoint: Optional[Text] = ...
+) -> Text: ...