python-minifier 3.0.0__tar.gz → 3.1.1__tar.gz

python_minifier-3.1.1/MANIFEST.in

@@ -0,0 +1,21 @@
+include README.md
+include LICENSE
+include setup.py
+graft src/python_minifier
+graft test
+exclude .gitignore
+exclude tox.ini
+exclude tox-windows.ini
+exclude requirements-dev.txt
+exclude CHANGELOG.md
+prune .github
+prune .config
+prune docker
+prune docs
+prune corpus_test
+prune hypo_test
+prune typing_test
+prune xtest
+prune tox
+global-exclude *.pyc
+global-exclude __pycache__

{python_minifier-3.0.0/src/python_minifier.egg-info → python_minifier-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_minifier
-Version: 3.0.0
+Version: 3.1.1
 Summary: Transform Python source code into it's most compact representation
 Home-page: https://github.com/dflook/python-minifier
 Author: Daniel Flook
@@ -25,13 +25,14 @@ Classifier: Programming Language :: Python :: 3.10
 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 :: 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.14
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author
@@ -53,7 +54,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.13. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. Previous releases supported Python 2.6.
 
 * [PyPI](https://pypi.org/project/python-minifier/)
 * [Documentation](https://dflook.github.io/python-minifier/)
@@ -159,7 +160,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.13.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
 
 ## Usage
 

{python_minifier-3.0.0 → python_minifier-3.1.1}/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.13. Previous releases supported Python 2.6.
+python-minifier currently supports Python 2.7 and Python 3.3 to 3.14. 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.13.
+python-minifier runs with and can minify code written for Python 2.7 and Python 3.3 to 3.14.
 
 ## Usage
 

{python_minifier-3.0.0 → python_minifier-3.1.1}/setup.py

@@ -20,15 +20,14 @@ setup(
     },
     keywords='minify minifier',
 
-    
     package_dir={'': 'src'},
     packages=find_packages('src'),
     package_data={"python_minifier": ["py.typed", "*.pyi", "rename/*.pyi", "transforms/*.pyi"]},
     long_description=long_desc,
     long_description_content_type='text/markdown',
 
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.14',
-    version='3.0.0',
+    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <3.15',
+    version='3.1.1',
 
     classifiers=[
         'Development Status :: 5 - Production/Stable',
@@ -46,6 +45,7 @@ setup(
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
         'Programming Language :: Python :: 3.13',
+        'Programming Language :: Python :: 3.14',
         'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: Implementation :: CPython',

{python_minifier-3.0.0 → python_minifier-3.1.1}/src/python_minifier/ast_compare.py

@@ -59,11 +59,14 @@ def compare_ast(l_ast, r_ast):
     if type(l_ast) != type(r_ast):
         raise CompareError(l_ast, r_ast, msg='Nodes do not match! %r != %r' % (l_ast, r_ast))
 
-    for field in set(l_ast._fields + r_ast._fields):
+    for field in sorted(set(l_ast._fields + r_ast._fields)):
 
         if field == 'kind' and isinstance(l_ast, ast.Constant):
             continue
 
+        if field == 'str' and hasattr(ast, 'Interpolation') and isinstance(l_ast, ast.Interpolation):
+            continue
+
         if isinstance(getattr(l_ast, field, None), list):
 
             l_list = getattr(l_ast, field, None)

{python_minifier-3.0.0 → python_minifier-3.1.1}/src/python_minifier/ast_compat.py

@@ -70,9 +70,11 @@ for _node_type in [
     'TryStar',
     'TypeVar',
     'TypeVarTuple',
+    'TemplateStr',
+    'Interpolation',
     'YieldFrom',
     'arg',
     'withitem',
 ]:
     if _node_type not in globals():
-        globals()[_node_type] = type(_node_type, (AST,), {})
+        globals()[_node_type] = type(_node_type, (AST,), {})

{python_minifier-3.0.0 → python_minifier-3.1.1}/src/python_minifier/expression_printer.py

@@ -301,8 +301,8 @@ class ExpressionPrinter(object):
 
             if value_precedence != 0 and (
                 (op_precedence > value_precedence)
-                or op_precedence == value_precedence
-                and self._is_left_associative(node.op)
+                or (op_precedence == value_precedence
+                    and self._is_left_associative(node.op))
             ):
                 self.printer.delimiter('(')
                 self._expression(v)
@@ -743,6 +743,13 @@ class ExpressionPrinter(object):
 
         self.printer.fstring(str(python_minifier.f_string.OuterFString(node, pep701=pep701)))
 
+    def visit_TemplateStr(self, node):
+        assert isinstance(node, ast.TemplateStr)
+
+        import python_minifier.t_string
+
+        self.printer.tstring(str(python_minifier.t_string.TString(node)))
+
     def visit_NamedExpr(self, node):
         self._expression(node.target)
         self.printer.operator(':=')

{python_minifier-3.0.0 → python_minifier-3.1.1}/src/python_minifier/f_string.py

@@ -8,6 +8,7 @@ Mostly because FStrings feel like a hack.
 
 import copy
 import re
+import sys
 
 import python_minifier.ast_compat as ast
 
@@ -58,11 +59,12 @@ class FString(object):
 
         return [x + '}' for x in conversion_candidates]
 
-    def candidates(self):
-        actual_candidates = []
+    def _generate_candidates_with_processor(self, prefix, str_processor):
+        """Generate f-string candidates using the given prefix and string processor function."""
+        candidates = []
 
         for quote in self.allowed_quotes:
-            candidates = ['']
+            quote_candidates = ['']
             debug_specifier_candidates = []
             nested_allowed = copy.copy(self.allowed_quotes)
 
@@ -71,26 +73,24 @@ class FString(object):
 
             for v in self.node.values:
                 if is_constant_node(v, ast.Str):
-
                     # Could this be used as a debug specifier?
-                    if len(candidates) < 10:
+                    if len(quote_candidates) < 10:
                         debug_specifier = re.match(r'.*=\s*$', v.s)
                         if debug_specifier:
-                            # Maybe!
                             try:
-                                debug_specifier_candidates = [x + '{' + v.s for x in candidates]
+                                debug_specifier_candidates = [x + '{' + v.s for x in quote_candidates]
                             except Exception:
                                 continue
 
                     try:
-                        candidates = [x + self.str_for(v.s, quote) for x in candidates]
+                        quote_candidates = [x + str_processor(v.s, quote) for x in quote_candidates]
                     except Exception:
                         continue
                 elif isinstance(v, ast.FormattedValue):
                     try:
                         completed = self.complete_debug_specifier(debug_specifier_candidates, v)
-                        candidates = [
-                            x + y for x in candidates for y in FormattedValue(v, nested_allowed, self.pep701).get_candidates()
+                        quote_candidates = [
+                            x + y for x in quote_candidates for y in FormattedValue(v, nested_allowed, self.pep701).get_candidates()
                         ] + completed
                         debug_specifier_candidates = []
                     except Exception:
@@ -98,13 +98,70 @@ class FString(object):
                 else:
                     raise RuntimeError('Unexpected JoinedStr value')
 
-                actual_candidates += ['f' + quote + x + quote for x in candidates]
+            candidates += [prefix + quote + x + quote for x in quote_candidates]
+
+        return candidates
+
+    def candidates(self):
+        actual_candidates = []
+
+        # Normal f-string candidates
+        actual_candidates += self._generate_candidates_with_processor('f', self.str_for)
+
+        # Raw f-string candidates (if we detect backslashes)
+        if self._contains_literal_backslashes():
+            actual_candidates += self._generate_candidates_with_processor('rf', lambda s, quote: self.raw_str_for(s))
 
         return filter(self.is_correct_ast, actual_candidates)
 
-    def str_for(self, s, quote):
+    def raw_str_for(self, s):
+        """
+        Generate string representation for raw f-strings.
+        Don't escape backslashes like MiniString does.
+        """
         return s.replace('{', '{{').replace('}', '}}')
 
+    def _contains_literal_backslashes(self):
+        """
+        Check if this f-string contains literal backslashes in constant values.
+        This indicates it may need to be a raw f-string.
+        """
+        for node in ast.walk(self.node):
+            if is_constant_node(node, ast.Str):
+                if '\\' in node.s:
+                    return True
+        return False
+
+
+    def str_for(self, s, quote):
+        # Escape null bytes and other characters that can't appear in Python source
+        escaped = ''
+        is_multiline = len(quote) == 3  # Triple-quoted strings
+
+        for c in s:
+            if c == '\0':
+                escaped += '\\x00'
+            elif c == '\n' and not is_multiline:
+                # Only escape newlines in single-quoted strings
+                escaped += '\\n'
+            elif c == '\r':
+                # Always escape carriage returns because Python normalizes them during parsing
+                # This prevents semantic changes (\\r -> \\n) in multiline strings
+                escaped += '\\r'
+            elif c == '\t':
+                # Always escape tabs for consistency (though not strictly necessary in multiline)
+                escaped += '\\t'
+            elif c == '{':
+                escaped += '{{'
+            elif c == '}':
+                escaped += '}}'
+            elif ord(c) < 32 and c not in '\n\r\t':
+                # Escape other control characters
+                escaped += '\\x{:02x}'.format(ord(c))
+            else:
+                escaped += c
+        return escaped
+
 
 class OuterFString(FString):
     """
@@ -285,7 +342,9 @@ class Str(object):
             if literal == '':
                 literal += self.current_quote
 
-            if c == '\n':
+            if c == '\0':
+                literal += '\\x00'
+            elif c == '\n':
                 literal += '\\n'
             elif c == '\r':
                 literal += '\\r'
@@ -302,7 +361,7 @@ class Str(object):
         if self._s == '':
             return str(min(self.allowed_quotes, key=len)) * 2
 
-        if '\0' in self._s or ('\\' in self._s and not self.pep701):
+        if '\\' in self._s and not self.pep701:
             raise ValueError('Impossible to represent a character in f-string expression part')
 
         if not self.pep701 and ('\n' in self._s or '\r' in self._s):
@@ -360,7 +419,35 @@ class FormatSpec(object):
         return candidates
 
     def str_for(self, s):
-        return s.replace('{', '{{').replace('}', '}}')
+        # Special handling for problematic format spec characters that can cause parsing issues
+        # If the format spec contains only braces, it's likely an invalid test case
+
+        # Escape null bytes and other unprintable characters
+        escaped = ''
+        for c in s:
+            if c == '\0':
+                escaped += '\\x00'
+            elif c == '{':
+                escaped += '{{'
+            elif c == '}':
+                escaped += '}}'
+            elif c == '\\':
+                # For Python 3.12+ raw f-string regression (fixed in 3.14rc2), we need to escape backslashes
+                # in format specs so they round-trip correctly
+                if (3, 12) <= sys.version_info < (3, 14):
+                    escaped += '\\\\'
+                else:
+                    escaped += c
+            elif c == '\r':
+                # Always escape carriage returns because Python normalizes them to newlines during parsing
+                # This prevents AST mismatches (\r -> \n normalization)
+                escaped += '\\r'
+            elif ord(c) < 32 and c not in '\t\n':
+                # Escape other control characters except tab, newline
+                escaped += '\\x{:02x}'.format(ord(c))
+            else:
+                escaped += c
+        return escaped
 
 
 class Bytes(object):
@@ -411,7 +498,24 @@ class Bytes(object):
 
             if literal == '':
                 literal = 'b' + self.current_quote
-            literal += chr(b)
+
+            # Handle special characters that need escaping
+            if b == 0:  # null byte
+                literal += '\\x00'
+            elif b == ord('\\'):  # backslash
+                literal += '\\\\'
+            elif b == ord('\n'):  # newline
+                literal += '\\n'
+            elif b == ord('\r'):  # carriage return
+                literal += '\\r'
+            elif b == ord('\t'):  # tab
+                literal += '\\t'
+            elif len(self.current_quote) == 1 and b == ord(self.current_quote):  # single quote character
+                literal += '\\' + self.current_quote
+            elif 32 <= b <= 126:  # printable ASCII
+                literal += chr(b)
+            else:  # other non-printable characters
+                literal += '\\x{:02x}'.format(b)
 
         if literal:
             literal += self.current_quote
@@ -421,8 +525,6 @@ class Bytes(object):
         if self._b == b'':
             return 'b' + str(min(self.allowed_quotes, key=len)) * 2
 
-        if b'\0' in self._b or b'\\' in self._b:
-            raise ValueError('Impossible to represent a %r character in f-string expression part')
 
         if b'\n' in self._b or b'\r' in self._b:
             if '"""' not in self.allowed_quotes and "'''" not in self.allowed_quotes:

{python_minifier-3.0.0 → python_minifier-3.1.1}/src/python_minifier/module_printer.py

@@ -596,7 +596,7 @@ class ModulePrinter(ExpressionPrinter):
         self.printer.keyword('case')
 
         if isinstance(node.pattern, ast.MatchSequence):
-            self.visit_MatchSequence(node.pattern, open=True)
+            self.visit_MatchSequence(node.pattern, omit_brackets=True)
         else:
             self.pattern(node.pattern)
 
@@ -626,10 +626,10 @@ class ModulePrinter(ExpressionPrinter):
         else:
             self.printer.identifier(node.name)
 
-    def visit_MatchSequence(self, node, open=False):
+    def visit_MatchSequence(self, node, omit_brackets=False):
         assert isinstance(node, ast.MatchSequence)
 
-        if len(node.patterns) < 2 or not open:
+        if len(node.patterns) < 2 or not omit_brackets:
             self.printer.delimiter('[')
 
         delimiter = Delimiter(self.printer)
@@ -637,7 +637,7 @@ class ModulePrinter(ExpressionPrinter):
             delimiter.new_item()
             self.pattern(pattern)
 
-        if len(node.patterns) < 2 or not open:
+        if len(node.patterns) < 2 or not omit_brackets:
             self.printer.delimiter(']')
 
     def visit_MatchMapping(self, node):

python_minifier-3.1.1/src/python_minifier/rename/README.md

@@ -0,0 +1,93 @@
+# Renaming
+
+We can save bytes by shortening the names used in a python program.
+
+One simple way to do this is to replace each unique name in a module with a shorter one.
+This will probably exhaust the available single character names, so is not as efficient as it could be.
+Also, not all names can be safely changed this way.
+
+By determining the scope of each name, we can assign the same short name to multiple non-overlapping scopes.
+This means sibling namespaces may have the same names, and names will be shadowed in inner namespaces where possible.
+
+This file is a guide for how the python_minifier package shortens names.
+There are multiple steps to the renaming process.
+
+## Binding Names
+
+Names are bound to the local namespace it is defined in.
+
+### Create namespace nodes
+
+Namespaces in python are introduced by Modules, Functions, Comprehensions, Generators and Classes.
+The AST node that introduces a new namespace is called a 'namespace node'.
+
+These attributes are added to namespace nodes:
+
+- Bindings - A list of Bindings local to this namespace, populated by the Bind names step
+- Globals - A list of global names in this namespace
+- Nonlocals - A list of nonlocal names in this namespace
+
+### Determine parent node
+
+Add a parent attribute to each node with the value of the node of which this is a child.
+
+### Determine namespace
+
+Add a namespace attribute to each node with the value of the namespace node that will be used for name binding and resolution.
+This is usually the closest parent namespace node. The exceptions are:
+
+- Function argument default values are in the same namespace as their function.
+- Function decorators are in the same namespace as their function.
+- Function annotations are in the same namespace as their function.
+- Class decorator are in the same namespace as their class.
+- Class bases, keywords, starargs and kwargs are in the same namespace as their class.
+- The first iteration expression of a comprehension is in the same namespace as it's parent ListComp/SetComp/DictComp or GeneratorExp.
+
+### Bind names
+
+Every node that binds a name creates a NameBinding for that name in its namespace.
+The node is added to the NameBinding as a reference.
+
+If the name is nonlocal in its namespace it does not create a binding.
+
+Nodes that create a binding:
+
+- FunctionDef nodes bind their name
+- ClassDef nodes bind their name
+- arg nodes bind their arg
+- Name nodes in Store or Del context bind their id
+- MatchAs nodes bind their name
+- MatchStar nodes bind their name
+- MatchMapping nodes bind their rest
+
+### Resolve names
+
+For the remaining unbound name nodes and nodes that normally create a binding but are for a nonlocal name, we find their binding.
+
+Bindings for name references are found by searching their namespace, then parent namespaces.
+If a name is global in a searched namespace, skip straight to the module node.
+If a name is nonlocal in a searched namespace, skip to the next parent namespace.
+When traversing parent namespaces, Class namespaces are skipped.
+
+If a NameBinding is found, add the node as a reference.
+If no NameBinding is found, check if the name would resolve to a builtin.
+If so, create a BuiltinBinding in the module namespace and add this node as a reference.
+
+Otherwise we failed to find a binding for this name - Create a NameBinding in the module namespace and add this node
+as a reference.
+
+## Hoist Literals
+
+At this point we do the HoistLiterals transform, which adds new HoistedLiteral bindings to the namespaces where it wants
+to introduce new names.
+
+## Name Assignment
+
+Collect all bindings in the module and sort by estimated byte savings
+
+For each binding:
+
+- Determine it's 'reservation scope', which is the set of namespaces that name is referenced in (and all namespaces between them)
+- Get the next available name that is unassigned and unreserved in all namespaces in the reservation scope.
+- Check if we should proceed with the rename - is it space efficient to do this rename, or has the original name been assigned somewhere else?
+- Rename the binding, rename all referenced nodes to the new name, and record this name as assigned in every namespace of the reservation scope.

{python_minifier-3.0.0 → python_minifier-3.1.1}/src/python_minifier/rename/rename_literals.py

@@ -220,6 +220,13 @@ class HoistLiterals(NodeVisitor):
                 continue
             self.visit(v)
 
+    def visit_TemplateStr(self, node):
+        for v in node.values:
+            if is_constant_node(v, ast.Str):
+                # Can't hoist string literals that are part of the template
+                continue
+            self.visit(v)
+
     def visit_NameConstant(self, node):
         self.get_binding(node.value, node).add_reference(node)
 

{python_minifier-3.0.0 → python_minifier-3.1.1}/src/python_minifier/rename/renamer.py

@@ -35,7 +35,7 @@ def sorted_bindings(module):
     """
 
     def comp(tup):
-        namespace, binding = tup
+        _namespace, binding = tup
         return binding.new_mention_count()
 
     return sorted(all_bindings(module), key=comp, reverse=True)