python-minifier 3.1.1__py2-none-any.whl → 3.2.0__py2-none-any.whl

python_minifier/__init__.py

@@ -72,7 +72,8 @@ def minify(
     remove_debug=False,
     remove_explicit_return_none=True,
     remove_builtin_exception_brackets=True,
-    constant_folding=True
+    constant_folding=True,
+    prefer_single_line=False,
 ):
     """
     Minify a python module
@@ -107,6 +108,7 @@ def minify(
     :param bool remove_explicit_return_none: If explicit return None statements should be replaced with a bare return
     :param bool remove_builtin_exception_brackets: If brackets should be removed when raising exceptions with no arguments
     :param bool constant_folding: If literal expressions should be evaluated
+    :param bool prefer_single_line: If semi-colons should be preferred over newlines where there is no difference in output size
 
     :rtype: str
 
@@ -192,7 +194,7 @@ def minify(
     if convert_posargs_to_args:
         module = remove_posargs(module)
 
-    minified = unparse(module)
+    minified = unparse(module, prefer_single_line=prefer_single_line)
 
     if preserve_shebang is True:
         shebang_line = _find_shebang(source)
@@ -219,7 +221,7 @@ def _find_shebang(source):
     return None
 
 
-def unparse(module):
+def unparse(module, prefer_single_line=False):
     """
     Turn a module AST into python code
 
@@ -228,13 +230,14 @@ def unparse(module):
 
     :param module: The module to turn into python code
     :type: module: :class:`ast.Module`
+    :param bool prefer_single_line: If semi-colons should be preferred over newlines where there is no difference in output size
     :rtype: str
 
     """
 
     assert isinstance(module, ast.Module)
 
-    printer = ModulePrinter()
+    printer = ModulePrinter(prefer_single_line=prefer_single_line)
     printer(module)
 
     try:

python_minifier/__init__.pyi

@@ -28,11 +28,15 @@ def minify(
     remove_debug: bool = ...,
     remove_explicit_return_none: bool = ...,
     remove_builtin_exception_brackets: bool = ...,
-    constant_folding: bool = ...
+    constant_folding: bool = ...,
+    prefer_single_line: bool = ...
 ) -> Text: ...
 
 
-def unparse(module: ast.Module) -> Text: ...
+def unparse(
+    module: ast.Module,
+    prefer_single_line: bool = ...
+) -> Text: ...
 
 
 def awslambda(

python_minifier/__main__.py

@@ -140,6 +140,13 @@ def parse_args():
         dest='in_place'
     )
 
+    parser.add_argument(
+        '--prefer-single-line',
+        action='store_true',
+        help='Prefer multiple statements on a single line separated by semicolons, instead of newlines, where there is no difference in output size',
+        dest='prefer_single_line',
+    )
+
     # Minification arguments
     minification_options = parser.add_argument_group('minification options', 'Options that affect how the source is minified')
     minification_options.add_argument(
@@ -373,7 +380,8 @@ def do_minify(source, filename, minification_args):
         remove_debug=minification_args.remove_debug,
         remove_explicit_return_none=minification_args.remove_explicit_return_none,
         remove_builtin_exception_brackets=minification_args.remove_exception_brackets,
-        constant_folding=minification_args.constant_folding
+        constant_folding=minification_args.constant_folding,
+        prefer_single_line=minification_args.prefer_single_line,
     )
 
     # Encode minified result to bytes for comparison and output

python_minifier/expression_printer.py

@@ -11,7 +11,7 @@ class ExpressionPrinter(object):
     Builds the smallest possible exact representation of an ast
     """
 
-    def __init__(self):
+    def __init__(self, prefer_single_line=False):
 
         self.precedences = {
             'Lambda': 2,  # Lambda
@@ -34,7 +34,7 @@ class ExpressionPrinter(object):
             'Tuple': 18, 'Set': 18, 'List': 18, 'Dict': 18, 'ListComp': 18, 'SetComp': 18, 'DictComp': 18, 'GeneratorExp': 18,  # Container
         }
 
-        self.printer = TokenPrinter()
+        self.printer = TokenPrinter(prefer_single_line=prefer_single_line)
 
     def __call__(self, module):
         """

python_minifier/module_printer.py

@@ -11,8 +11,8 @@ class ModulePrinter(ExpressionPrinter):
     Builds the smallest possible exact representation of an ast
     """
 
-    def __init__(self, indent_char='\t'):
-        super(ModulePrinter, self).__init__()
+    def __init__(self, indent_char='\t', prefer_single_line=False):
+        super(ModulePrinter, self).__init__(prefer_single_line=prefer_single_line)
         self.indent_char = indent_char
 
     def __call__(self, module):

python_minifier/token_printer.py

@@ -306,7 +306,7 @@ class TokenPrinter(object):
     def end_statement(self):
         """ End a statement with a newline, or a semi-colon if it saves characters. """
 
-        if self.indent == 0:
+        if self.indent == 0 and not self._prefer_single_line:
             self.newline()
         else:
             if self._code[-1] != ';':

python_minifier/transforms/constant_folding.py

@@ -10,36 +10,35 @@ from python_minifier.transforms.suite_transformer import SuiteTransformer
 from python_minifier.util import is_constant_node
 
 
-class FoldConstants(SuiteTransformer):
-    """
-    Fold Constants if it would reduce the size of the source
+def is_foldable_constant(node):
     """
+    Check if a node is a constant expression that can participate in folding.
 
-    def __init__(self):
-        super(FoldConstants, self).__init__()
+    We can asume that children have already been folded, so foldable constants are either:
+    - Simple literals (Num, NameConstant)
+    - UnaryOp(USub/Invert) on a Num - these don't fold to shorter forms,
+      so they remain after child visiting. UAdd and Not would have been
+      folded away since they always produce shorter results.
+    """
+    if is_constant_node(node, (ast.Num, ast.NameConstant)):
+        return True
 
-    def visit_BinOp(self, node):
+    if isinstance(node, ast.UnaryOp):
+        if isinstance(node.op, (ast.USub, ast.Invert)):
+            return is_constant_node(node.operand, ast.Num)
 
-        node.left = self.visit(node.left)
-        node.right = self.visit(node.right)
+    return False
 
-        # Check this is a constant expression that could be folded
-        # We don't try to fold strings or bytes, since they have probably been arranged this way to make the source shorter and we are unlikely to beat that
-        if not is_constant_node(node.left, (ast.Num, ast.NameConstant)):
-            return node
-        if not is_constant_node(node.right, (ast.Num, ast.NameConstant)):
-            return node
 
-        if isinstance(node.op, ast.Div):
-            # Folding div is subtle, since it can have different results in Python 2 and Python 3
-            # Do this once target version options have been implemented
-            return node
+class FoldConstants(SuiteTransformer):
+    """
+    Fold Constants if it would reduce the size of the source
+    """
 
-        if isinstance(node.op, ast.Pow):
-            # This can be folded, but it is unlikely to reduce the size of the source
-            # It can also be slow to evaluate
-            return node
+    def __init__(self):
+        super(FoldConstants, self).__init__()
 
+    def fold(self, node):
         # Evaluate the expression
         try:
             original_expression = unparse_expression(node)
@@ -96,6 +95,44 @@ class FoldConstants(SuiteTransformer):
         # New representation is shorter and has the same value, so use it
         return self.add_child(new_node, get_parent(node), node.namespace)
 
+    def visit_BinOp(self, node):
+
+        node.left = self.visit(node.left)
+        node.right = self.visit(node.right)
+
+        # Check this is a constant expression that could be folded
+        # We don't try to fold strings or bytes, since they have probably been arranged this way to make the source shorter and we are unlikely to beat that
+        if not is_foldable_constant(node.left):
+            return node
+        if not is_foldable_constant(node.right):
+            return node
+
+        if isinstance(node.op, ast.Div):
+            # Folding div is subtle, since it can have different results in Python 2 and Python 3
+            # Do this once target version options have been implemented
+            return node
+
+        if isinstance(node.op, ast.Pow):
+            # This can be folded, but it is unlikely to reduce the size of the source
+            # It can also be slow to evaluate
+            return node
+
+        return self.fold(node)
+
+    def visit_UnaryOp(self, node):
+
+        node.operand = self.visit(node.operand)
+
+        # Only fold if the operand is a foldable constant
+        if not is_foldable_constant(node.operand):
+            return node
+
+        # Only fold these unary operators
+        if not isinstance(node.op, (ast.USub, ast.UAdd, ast.Invert, ast.Not)):
+            return node
+
+        return self.fold(node)
+
 
 def equal_value_and_type(a, b):
     if type(a) != type(b):

{python_minifier-3.1.1.dist-info → python_minifier-3.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-minifier
-Version: 3.1.1
+Version: 3.2.0
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook

{python_minifier-3.1.1.dist-info → python_minifier-3.2.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
-python_minifier/__init__.py,sha256=Q95ufDbd7hadjVtJZYclsJqX9S4NsKZSpqCui0Fw7oI,9542
-python_minifier/__init__.pyi,sha256=-xLoKXbQsV7ko_YzyXL9WkI2vmGc6yn4AW5biK_GJXE,1233
-python_minifier/__main__.py,sha256=r7_Vh9n-aoc4jd5CERKO3KqJeqXHeWoycDRlvV7xTFM,14053
+python_minifier/__init__.py,sha256=L77ebjrfZzWX9Xdpza_Z2Io0WyPRl24euDpXl0-8l8k,9933
+python_minifier/__init__.pyi,sha256=PM-ZRAim7MdSSn4-ts3KrgagxoeCXTL5S2lGEVSjU9I,1311
+python_minifier/__main__.py,sha256=4hpug2STfQwMKQS2adA_19aQm0vke38Y6ZYNAzShm-0,14397
 python_minifier/ast_compare.py,sha256=KQyS9TGA1SoCs8uu4iks1IINFb_pEj7x38Q4oiERWnI,3381
 python_minifier/ast_compat.py,sha256=DFJ7WmrEfYXfaby8EWt1aRlcqVPPoXD4Fh9Hnb9dLCU,2250
 python_minifier/ast_printer.py,sha256=TlkyKl9_9ScWeop3W1TwXZ46MJWINfkJ7NvmULpwt4A,3254
-python_minifier/expression_printer.py,sha256=rBegwnqsjT_buJwSqK_piLwnfCwPyshzUUYgShoZPB4,22676
+python_minifier/expression_printer.py,sha256=DYun-j66MOdY3aTNRdfokFyJASc1uCNzAxuUG401D6Y,22739
 python_minifier/f_string.py,sha256=eXYXaxEMSB3iHY_M_RXYpeloJV-7TYnhWIGge0KYCk8,18314
 python_minifier/ministring.py,sha256=R0xaAZqMlLu1Jm0aBVSI0n8KZiZV7PTs4RE4UbCmTy8,4359
-python_minifier/module_printer.py,sha256=zVdsUXm2GkdbIbNUyuavaOWRhn7FP93UqRibhuiokfQ,25602
+python_minifier/module_printer.py,sha256=kLQqRAqkg1-UDvjvz_7R2UBkV_yoDKVheVR9P6LbckA,25665
 python_minifier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_minifier/t_string.py,sha256=z3KzWaSDqvy701SY3dm8VSkiJuiUfopSWGNIm-nDpAo,13261
-python_minifier/token_printer.py,sha256=MoVyC_ufvTXtI5bAIq6XdWDrkUTF6oYBmto3ILfq_KU,9983
+python_minifier/token_printer.py,sha256=mF56xx-rdq51gWzVvewh4LpobPfPcFAxOQ3GSMsTJi0,10016
 python_minifier/util.py,sha256=60iT3XkKlPlZhXQ1NuLB27Wv3ihl-gBC_WjOjEiFn-Q,1184
 python_minifier/ast_annotation/__init__.py,sha256=BJ4gyS-_bytIZf0SP8JJG6FECWf8MUaUi3vOAfD60qQ,2259
 python_minifier/rename/__init__.py,sha256=8DLEFgliakf_5T_m-l1Nd35QxKpM4h7RJyFVpjsxjWA,375
@@ -24,7 +24,7 @@ python_minifier/rename/resolve_names.py,sha256=VbePyUUqggvvcF3fAC6XMv6b3Kmb_cmlO
 python_minifier/rename/util.py,sha256=ItJykxM_QRjIePMcKYo-LngmP5hLQZK-bOZIefg1cKA,5469
 python_minifier/transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_minifier/transforms/combine_imports.py,sha256=7DkNBsTLiiEw01Epa2xj8zkAyVMG3pCTJNlZktqDwDI,2297
-python_minifier/transforms/constant_folding.py,sha256=wcCtjHa0WfYHI0Encs3IPHjZgumkN-ijNerMZgXu_g4,4538
+python_minifier/transforms/constant_folding.py,sha256=05i7hKmtAGKj26HvBY75OHdNo-OfAm6Q-aFIdij6y-0,5663
 python_minifier/transforms/remove_annotations.py,sha256=qUCdl42yvq1g7B43d88EOz6Jf51A5zogYBlFHGnyugU,4938
 python_minifier/transforms/remove_annotations_options.py,sha256=kzg-gEPwhrCZxsuzdpEWjqnhsyF89hnIPv1t-IRty64,1889
 python_minifier/transforms/remove_annotations_options.pyi,sha256=jZp8hUQ-BfqU1qA_nsPiluMM-1jznSX3pzbmysvKv-c,518
@@ -37,10 +37,10 @@ python_minifier/transforms/remove_object_base.py,sha256=j4se6OXyZK1lr_ABmGT0Oivu
 python_minifier/transforms/remove_pass.py,sha256=S9e59nBEZ8rBBifvAhbPRDTfUA7s8_a7pSIsZbFZD2A,735
 python_minifier/transforms/remove_posargs.py,sha256=aV0wFnGiDXu4uQBQP7-cB1uLSF3mamIq5-txvDg8BVo,314
 python_minifier/transforms/suite_transformer.py,sha256=WZCVkkBSniWeEtBybVweeMmy-A1wC3lBIYSgxCHelBU,6324
-python_minifier-3.1.1.dist-info/LICENSE,sha256=FzsyDHb8pAZupSGFjIOuHcHMlFf6N-aIxq9gOYGbNyE,1069
-python_minifier-3.1.1.dist-info/METADATA,sha256=szq8DMXjTaRYTE-tUW8lKyMiojWV2yyu6l2wGSaxu5k,6502
-python_minifier-3.1.1.dist-info/WHEEL,sha256=1VPi6hfNQaRRNuEdK_3dv9o8COtLGnHWJghhj4CQ28k,92
-python_minifier-3.1.1.dist-info/entry_points.txt,sha256=aS7ZUWQeeys8lAbrmmEa2__Bg-anH1tUMyi9cKdTbO4,60
-python_minifier-3.1.1.dist-info/top_level.txt,sha256=4SRDfWKi_KMq7LDrjlzUFoDCs6INYPtxc1Pun4z8LsU,16
-python_minifier-3.1.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-python_minifier-3.1.1.dist-info/RECORD,,
+python_minifier-3.2.0.dist-info/LICENSE,sha256=FzsyDHb8pAZupSGFjIOuHcHMlFf6N-aIxq9gOYGbNyE,1069
+python_minifier-3.2.0.dist-info/METADATA,sha256=aM3kblW9A58nv9sWw2x_ebASoSGuuO-3u5MSuxItNzk,6502
+python_minifier-3.2.0.dist-info/WHEEL,sha256=1VPi6hfNQaRRNuEdK_3dv9o8COtLGnHWJghhj4CQ28k,92
+python_minifier-3.2.0.dist-info/entry_points.txt,sha256=aS7ZUWQeeys8lAbrmmEa2__Bg-anH1tUMyi9cKdTbO4,60
+python_minifier-3.2.0.dist-info/top_level.txt,sha256=4SRDfWKi_KMq7LDrjlzUFoDCs6INYPtxc1Pun4z8LsU,16
+python_minifier-3.2.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+python_minifier-3.2.0.dist-info/RECORD,,