python-minifier 3.3.0__tar.gz → 3.4.0__tar.gz

{python_minifier-3.3.0/src/python_minifier.egg-info → python_minifier-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.3.0
+Version: 3.4.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -26,13 +26,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.16
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author
@@ -54,7 +55,7 @@ Transforms Python source code into its most compact representation.
 
 [Try it out!](https://python-minifier.com)
 
-python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.15. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -160,7 +161,7 @@ and outputs source code compatible with the version of the interpreter it is run
 This means that if you minify code written for Python 3.11 using python-minifier running with Python 3.12,
 the minified code may only run with Python 3.12.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.15.
 
 ## Usage
 

{python_minifier-3.3.0 → python_minifier-3.4.0}/README.md

@@ -4,7 +4,7 @@ Transforms Python source code into its most compact representation.
 
 [Try it out!](https://python-minifier.com)
 
-python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.15. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -110,7 +110,7 @@ and outputs source code compatible with the version of the interpreter it is run
 This means that if you minify code written for Python 3.11 using python-minifier running with Python 3.12,
 the minified code may only run with Python 3.12.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.15.
 
 ## Usage
 

{python_minifier-3.3.0 → python_minifier-3.4.0}/setup.py

@@ -26,8 +26,8 @@ setup(
     long_description=long_desc,
     long_description_content_type='text/markdown',
 
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15',
-    version='3.3.0',
+    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.16',
+    version='3.4.0',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',
@@ -46,6 +46,7 @@ setup(
         'Programming Language :: Python :: 3.12',
         'Programming Language :: Python :: 3.13',
         'Programming Language :: Python :: 3.14',
+        'Programming Language :: Python :: 3.15',
         'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: Implementation :: CPython',

{python_minifier-3.3.0 → python_minifier-3.4.0}/src/python_minifier/expression_printer.py

@@ -524,9 +524,15 @@ class ExpressionPrinter(object):
 
     def visit_DictComp(self, node):
         self.printer.delimiter('{')
-        self._expression(node.key)
-        self.printer.delimiter(':')
-        self._expression(node.value)
+
+        if node.value is None:
+            self.printer.operator('**')
+            self._expression(node.key)
+        else:
+            self._expression(node.key)
+            self.printer.delimiter(':')
+            self._expression(node.value)
+
         [self.visit_comprehension(x) for x in node.generators]
         self.printer.delimiter('}')
 

{python_minifier-3.3.0 → python_minifier-3.4.0}/src/python_minifier/module_printer.py

@@ -234,6 +234,8 @@ class ModulePrinter(ExpressionPrinter):
     def visit_Import(self, node):
         assert isinstance(node, ast.Import)
 
+        if getattr(node, 'is_lazy', 0) == 1:
+            self.printer.keyword('lazy')
         self.printer.keyword('import')
 
         delimiter = Delimiter(self.printer)
@@ -246,6 +248,9 @@ class ModulePrinter(ExpressionPrinter):
     def visit_ImportFrom(self, node):
         assert isinstance(node, ast.ImportFrom)
 
+        if getattr(node, 'is_lazy', 0) == 1:
+            self.printer.keyword('lazy')
+
         self.printer.keyword('from')
         for _i in range(node.level):
             self.printer.delimiter('.')

{python_minifier-3.3.0 → python_minifier-3.4.0}/src/python_minifier/rename/mapper.py

@@ -104,7 +104,9 @@ def add_parent_to_comprehension(node, namespace):
         add_parent(node.elt, namespace=node)
     elif hasattr(node, 'key'):
         add_parent(node.key, namespace=node)
-        add_parent(node.value, namespace=node)
+
+        if node.value is not None:
+            add_parent(node.value, namespace=node)
 
     iter_namespace = namespace
     for generator in node.generators:

{python_minifier-3.3.0 → python_minifier-3.4.0}/src/python_minifier/token_printer.py

@@ -130,7 +130,7 @@ class TokenPrinter(object):
             'or', 'pass', 'raise', 'return',
             'try', 'while', 'with', 'yield', '_',
             'case', 'match', 'print', 'exec',
-            'type'
+            'type', 'lazy'
         ]
 
         if self.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword, TokenTypes.NumberLiteral]:
@@ -138,7 +138,7 @@ class TokenPrinter(object):
 
         self._code += kw
 
-        if kw in ['_', 'case', 'match', 'type']:
+        if kw in ['_', 'case', 'match', 'type', 'lazy']:
             self.previous_token = TokenTypes.SoftKeyword
         else:
             self.previous_token = TokenTypes.Keyword

python_minifier-3.4.0/src/python_minifier/transforms/combine_imports.py

@@ -0,0 +1,119 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.transforms.suite_transformer import SuiteTransformer
+
+
+def import_kwargs(import_node):
+    lazy = getattr(import_node, 'is_lazy', None)
+    if lazy is None:
+        return {}
+    return {'is_lazy': lazy}
+
+
+class CombineImports(SuiteTransformer):
+    """
+    Combine multiple import statements where possible
+
+    This doesn't change the order of imports
+
+    """
+
+    def _combine_import(self, node_list, parent):
+
+        prev_import = None
+        alias = []
+
+        def can_merge_with_previous_group(statement):
+            if not isinstance(statement, ast.Import):
+                return False
+
+            if prev_import is None:
+                return True
+
+            if getattr(statement, 'is_lazy', None) != getattr(prev_import, 'is_lazy', None):
+                return False
+
+            return True
+
+        def can_create_group(statement):
+            return isinstance(statement, ast.Import)
+
+        for statement in node_list:
+            if can_merge_with_previous_group(statement):
+                prev_import = statement
+                alias += statement.names
+            else:
+                if alias:
+                    yield self.add_child(ast.Import(names=alias, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace)
+                    prev_import = None
+                    alias = []
+
+                if can_create_group(statement):
+                    prev_import = statement
+                    alias += statement.names
+                else:
+                    yield statement
+
+        if alias:
+            yield self.add_child(ast.Import(names=alias, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace)
+
+    def _combine_import_from(self, node_list, parent):
+
+        prev_import = None
+        alias = []
+
+        def can_merge_with_previous_group(statement):
+            if not isinstance(statement, ast.ImportFrom):
+                return False
+
+            if len(statement.names) == 1 and statement.names[0].name == '*':
+                return False
+
+            if prev_import is None:
+                return True
+
+            if getattr(statement, 'is_lazy', None) != getattr(prev_import, 'is_lazy', None):
+                return False
+
+            if statement.module == prev_import.module and statement.level == prev_import.level:
+                return True
+
+            return False
+
+        def can_create_group(statement):
+            if not isinstance(statement, ast.ImportFrom):
+                return False
+
+            if len(statement.names) == 1 and statement.names[0].name == '*':
+                return False
+
+            return True
+
+        for statement in node_list:
+            if can_merge_with_previous_group(statement):
+                prev_import = statement
+                alias += statement.names
+            else:
+                if alias:
+                    yield self.add_child(
+                        ast.ImportFrom(module=prev_import.module, names=alias, level=prev_import.level, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace
+                    )
+                    prev_import = None
+                    alias = []
+
+                if can_create_group(statement):
+                    prev_import = statement
+                    alias += statement.names
+                else:
+                    yield statement
+
+        if alias:
+            yield self.add_child(
+                ast.ImportFrom(module=prev_import.module, names=alias, level=prev_import.level, **import_kwargs(prev_import)), parent=parent, namespace=prev_import.namespace
+            )
+
+    def suite(self, node_list, parent):
+        a = list(self._combine_import(node_list, parent))
+        b = list(self._combine_import_from(a, parent))
+
+        return [self.visit(n) for n in b]

{python_minifier-3.3.0 → python_minifier-3.4.0/src/python_minifier.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.3.0
+Version: 3.4.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -26,13 +26,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.16
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author
@@ -54,7 +55,7 @@ Transforms Python source code into its most compact representation.
 
 [Try it out!](https://python-minifier.com)
 
-python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.15. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -160,7 +161,7 @@ and outputs source code compatible with the version of the interpreter it is run
 This means that if you minify code written for Python 3.11 using python-minifier running with Python 3.12,
 the minified code may only run with Python 3.12.
 
-python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.15.
 
 ## Usage
 

{python_minifier-3.3.0 → python_minifier-3.4.0}/src/python_minifier.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ test/test_bind_names_python313.py
 test/test_bind_names_python33.py
 test/test_combine_imports.py
 test/test_comprehension_rename.py
+test/test_comprehension_unpacking.py
 test/test_decorator_expressions.py
 test/test_dict_expansion.py
 test/test_folding.py
@@ -73,6 +74,7 @@ test/test_hoist_literals.py
 test/test_import.py
 test/test_is_constant_node.py
 test/test_iterable_unpacking.py
+test/test_lazy_imports.py
 test/test_match.py
 test/test_match_rename.py
 test/test_name_generator.py

python_minifier-3.4.0/test/test_comprehension_unpacking.py

@@ -0,0 +1,188 @@
+"""
+PEP 798 - unpacking in comprehensions, new in Python 3.15
+
+    [*L for L in lists]      {*s for s in sets}
+    (*L for L in lists)      {**d for d in dicts}
+
+The dict form is represented as a DictComp whose `value` is None, with the
+unpacked expression in `key`. The iterable forms reuse Starred in the existing
+`elt` slot, so none of this changes any node's `_fields`.
+"""
+
+import ast
+import sys
+
+import pytest
+
+from python_minifier import minify, unparse
+from python_minifier.ast_compare import compare_ast
+
+
+def run(source):
+    """
+    Execute a module and return the data it defines, for comparing behaviour
+
+    Functions and classes are dropped: minifying renames them, and two function
+    objects never compare equal anyway, so only the values they compute are
+    useful for comparison.
+    """
+
+    namespace = {}
+    exec(compile(source, '<test>', 'exec'), namespace)
+    return {
+        k: v for k, v in namespace.items()
+        if not k.startswith('__') and not callable(v)
+    }
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+@pytest.mark.parametrize(
+    'statement', [
+        'x=[*L for L in lists]',
+        'x=[*L for L in lists if L]',
+        'x=[*(a,b)for a in c]',
+        'x={*s for s in sets}',
+        'x=(*L for L in lists)',
+        'x=[*L for L in lists for M in L]'
+    ]
+)
+def test_iterable_comprehension_unpacking_unparse(statement):
+    """The * form in list/set/generator comprehensions survives a print/parse round trip"""
+    assert unparse(ast.parse(statement)) == statement
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+@pytest.mark.parametrize(
+    'statement', [
+        'x={**d for d in dicts}',
+        'x={**d for d in dicts if d}',
+        "x={**{'a':1}for a in c}"
+    ]
+)
+def test_dict_comprehension_unpacking_unparse(statement):
+    """The ** form in dict comprehensions survives a print/parse round trip"""
+    assert unparse(ast.parse(statement)) == statement
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+@pytest.mark.parametrize(
+    'statement', [
+        'x=[*L for L in lists]',
+        'x={*s for s in sets}',
+        'x=(*L for L in lists)',
+        'x={**d for d in dicts}'
+    ]
+)
+def test_comprehension_unpacking_ast_preserved(statement):
+    """Minifying does not change what the comprehension means"""
+    expected_ast = ast.parse(statement)
+    actual_ast = ast.parse(unparse(ast.parse(statement)))
+    compare_ast(expected_ast, actual_ast)
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+def test_iterable_unpacking_behaviour_is_preserved():
+    source = '''
+lists = [[1, 2], [3, 4], [5]]
+sets = [{1, 2}, {2, 3}]
+flat_list = [*L for L in lists]
+flat_set = sorted({*s for s in sets})
+flat_gen = list((*L for L in lists))
+'''
+    assert run(minify(source)) == run(source)
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+def test_dict_unpacking_behaviour_is_preserved():
+    source = '''
+dicts = [{'a': 1}, {'b': 2}, {'a': 3}]
+merged = {**d for d in dicts}
+'''
+    assert run(minify(source)) == run(source)
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+def test_dict_unpacking_in_function_is_preserved():
+    """Renaming must reach inside the unpacked expression of a dict comprehension"""
+    source = '''
+def merge(dictionaries):
+    return {**dictionary for dictionary in dictionaries}
+result = merge([{'a': 1}, {'b': 2}])
+'''
+    assert run(minify(source)) == run(source)
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+def test_async_comprehension_unpacking():
+    source = 'async def f(g):return(*a async for a in g())'
+    assert unparse(ast.parse(source)) == source
+
+
+# PEP 798 only allows the unpacking operator at the *top level of the element
+# expression*, not nested inside a subexpression. How much of an expression the
+# operator swallows differs by comprehension kind, because the grammar rules
+# differ - listcomp/setcomp take `star_named_expression`, genexp takes
+# `starred_expression`, dictcomp takes `double_starred_kvpair`:
+#
+#     [*x if c else z for x in y]     SyntaxError - needs parentheses
+#     {*x if c else z for x in y}     SyntaxError - needs parentheses
+#     (*x if c else z for x in y)     legal - binds the whole conditional
+#     {**d if c else e for d in y}    legal - binds the whole conditional
+#
+# The restriction has nothing to do with which `for` clause is involved;
+# multiple and nested comprehensions are unrestricted.
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+@pytest.mark.parametrize(
+    'source', [
+        'q=[*x if c else z for x in y]',
+        'q={*x if c else z for x in y}',
+        'q=[**x for x in y]',
+        'q=(**x for x in y)',
+        'q={*k: v for k,v in y}'
+    ]
+)
+def test_unpacking_restrictions_are_syntax_errors(source):
+    """Forms PEP 798 does not allow, guarding the assumption the printer relies on"""
+    with pytest.raises(SyntaxError):
+        ast.parse(source)
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+@pytest.mark.parametrize(
+    ('source', 'expected'), [
+        # the iterable forms need the parentheses kept, or the result will not parse
+        ('q=[*(x if c else z) for x in y]', 'q=[*(x if c else z)for x in y]'),
+        ('q={*(x if c else z) for x in y}', 'q={*(x if c else z)for x in y}'),
+        # a tuple display element also needs its parentheses
+        ('q=[(*x, *z) for x in y]', 'q=[(*x,*z)for x in y]'),
+        # the dict form does not - the trailing `for` ends the expression
+        ('q={**(d if c else e) for d in y}', 'q={**d if c else e for d in y}'),
+        # the generator form does not require them either, but keeping them is
+        # still correct, and it is the only iterable form where they are optional
+        ('q=(*(x if c else z) for x in y)', 'q=(*(x if c else z)for x in y)')
+    ]
+)
+def test_unpacking_parenthesisation(source, expected):
+    """Parentheses are kept exactly where the grammar requires them, and dropped where it does not"""
+    assert unparse(ast.parse(source)) == expected
+    compare_ast(ast.parse(source), ast.parse(unparse(ast.parse(source))))
+
+
+@pytest.mark.skipif(sys.version_info < (3, 15), reason='Comprehension unpacking requires Python 3.15+')
+@pytest.mark.parametrize(
+    'source', [
+        'q=[*x for x in y for z in x]',
+        'q=[*x for x in y if x]',
+        'q=[[*x for x in y] for z in w]',
+        'q=[*[*x for x in y] for z in w]',
+        'q=[*(x := y) for r in s]',
+        'q=f(*x for x in y)',
+        'q=[*x + z for x in y]',
+        'q=[*(lambda: 1)() for x in y]',
+        'q=(*x if c else z for x in y)'
+    ]
+)
+def test_unpacking_in_compound_expressions(source):
+    """Unpacking composes with multiple for clauses, nesting, walrus and calls"""
+    compare_ast(ast.parse(source), ast.parse(unparse(ast.parse(source))))