python-minifier 2.11.2__py2-none-any.whl

python_minifier/transforms/suite_transformer.py

@@ -0,0 +1,196 @@
+import python_minifier.ast_compat as ast
+
+from python_minifier.rename.mapper import add_parent
+from python_minifier.util import is_ast_node
+
+
+class NodeVisitor(object):
+    def visit(self, node):
+        """Visit a node."""
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node)
+
+    def generic_visit(self, node):
+        """Called if no explicit visitor function exists for a node."""
+        for field, value in ast.iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ast.AST):
+                        self.visit(item)
+            elif isinstance(value, ast.AST):
+                self.visit(value)
+
+    def visit_Constant(self, node):
+        if node.value in [None, True, False]:
+            method = 'visit_NameConstant'
+        elif isinstance(node.value, (int, float, complex)):
+            method = 'visit_Num'
+        elif isinstance(node.value, str):
+            method = 'visit_Str'
+        elif isinstance(node.value, bytes):
+            method = 'visit_Bytes'
+        elif node.value == Ellipsis:
+            method = 'visit_Ellipsis'
+        else:
+            raise RuntimeError('Unknown Constant value %r' % type(node.value))
+
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node)
+
+
+class SuiteTransformer(NodeVisitor):
+    """
+    Transform suites of instructions
+    """
+
+    def __call__(self, node):
+        return self.visit(node)
+
+    def visit_ClassDef(self, node):
+        node.bases = [self.visit(b) for b in node.bases]
+
+        if hasattr(node, 'type_params') and node.type_params is not None:
+            node.type_params = [self.visit(t) for t in node.type_params]
+
+        node.body = self.suite(node.body, parent=node)
+        node.decorator_list = [self.visit(d) for d in node.decorator_list]
+
+        if hasattr(node, 'starargs') and node.starargs is not None:
+            node.starargs = self.visit(node.starargs)
+
+        if hasattr(node, 'kwargs') and node.kwargs is not None:
+            node.kwargs = self.visit(node.kwargs)
+
+        if hasattr(node, 'keywords'):
+            node.keywords = [self.visit(kw) for kw in node.keywords]
+
+        return node
+
+    def visit_FunctionDef(self, node):
+        node.args = self.visit(node.args)
+        node.body = self.suite(node.body, parent=node)
+        node.decorator_list = [self.visit(d) for d in node.decorator_list]
+
+        if hasattr(node, 'returns') and node.returns is not None:
+            node.returns = self.visit(node.returns)
+
+        return node
+
+    def visit_AsyncFunctionDef(self, node):
+        return self.visit_FunctionDef(node)
+
+    def visit_For(self, node):
+        node.target = self.visit(node.target)
+        node.iter = self.visit(node.iter)
+
+        node.body = self.suite(node.body, parent=node)
+
+        if node.orelse:
+            node.orelse = self.suite(node.orelse, parent=node)
+
+        return node
+
+    def visit_AsyncFor(self, node):
+        return self.visit_For(node)
+
+    def visit_If(self, node):
+        node.test = self.visit(node.test)
+
+        node.body = self.suite(node.body, parent=node)
+
+        if node.orelse:
+            node.orelse = self.suite(node.orelse, parent=node)
+
+        return node
+
+    def visit_Try(self, node):
+        node.body = self.suite(node.body, parent=node)
+
+        node.handlers = [self.visit(h) for h in node.handlers]
+
+        if node.orelse:
+            node.orelse = self.suite(node.orelse, parent=node)
+
+        if node.finalbody:
+            node.finalbody = self.suite(node.finalbody, parent=node)
+
+        return node
+
+    def visit_While(self, node):
+        node.test = self.visit(node.test)
+
+        node.body = self.suite(node.body, parent=node)
+
+        if node.orelse:
+            node.orelse = self.suite(node.orelse, parent=node)
+
+        return node
+
+    def visit_With(self, node):
+
+        if hasattr(node, 'items'):
+            node.items = [self.visit(i) for i in node.items]
+        else:
+            if node.context_expr:
+                node.context_expr = self.visit(node.context_expr)
+            if node.optional_vars:
+                node.optional_vars = self.visit(node.optional_vars)
+
+        node.body = self.suite(node.body, parent=node)
+        return node
+
+    def visit_AsyncWith(self, node):
+        return self.visit_With(node)
+
+    def visit_Module(self, node):
+        node.body = self.suite(node.body, parent=node)
+        return node
+
+    def suite(self, node_list, parent):
+        return [self.visit(node) for node in node_list]
+
+    def generic_visit(self, node):
+        for field, old_value in ast.iter_fields(node):
+            if isinstance(old_value, list):
+                new_values = []
+                for value in old_value:
+                    if isinstance(value, ast.AST):
+                        value = self.visit(value)
+                        if value is None:
+                            continue
+                        elif not isinstance(value, ast.AST):
+                            new_values.extend(value)
+                            continue
+                    new_values.append(value)
+                old_value[:] = new_values
+            elif isinstance(old_value, ast.AST):
+                new_node = self.visit(old_value)
+                if new_node is None:
+                    delattr(node, field)
+                else:
+                    setattr(node, field, new_node)
+        return node
+
+    def add_child(self, child, parent, namespace=None):
+        def nearest_function_namespace(node):
+            """
+            Return the namespace node for the nearest function scope.
+
+            This could be itself.
+
+            :param node: The node to get the function namespace of
+            :type node: ast.Node
+            :rtype: ast.Node
+
+            """
+
+            if is_ast_node(node, (ast.FunctionDef, ast.Module, 'AsyncFunctionDef')):
+                return node
+            return nearest_function_namespace(node.parent)
+
+        if namespace is None:
+            namespace = nearest_function_namespace(parent)
+
+        add_parent(child, parent=parent, namespace=namespace)
+        return child

python_minifier/util.py

@@ -0,0 +1,48 @@
+import python_minifier.ast_compat as ast
+
+def is_ast_node(node, types):
+    """
+    Is a node one of the specified node types
+
+    A node type may be an actual ast class, or a string naming one.
+    types is a single node type or an iterable of many.
+
+    If a node_type specified a specific Constant type (Str, Bytes, Num etc),
+    returns true for Constant nodes of the correct type.
+
+    :type node: ast.AST
+    :param types:
+    :rtype: bool
+
+    """
+
+    if not isinstance(types, tuple):
+        types = (types,)
+
+    actual_types = []
+    for node_type in types:
+        if isinstance(node_type, str):
+            node_type = getattr(ast, node_type, None)
+            if node_type is not None:
+                actual_types.append(node_type)
+        else:
+            actual_types.append(node_type)
+
+    if isinstance(node, tuple(actual_types)):
+        return True
+
+    if hasattr(ast, 'Constant') and isinstance(node, ast.Constant):
+        if type(node.value) in [type(None), type(True), type(False)]:
+            return ast.NameConstant in actual_types
+        elif isinstance(node.value, (int, float, complex)):
+            return ast.Num in actual_types
+        elif isinstance(node.value, str):
+            return ast.Str in actual_types
+        elif isinstance(node.value, bytes):
+            return ast.Bytes in actual_types
+        elif node.value == Ellipsis:
+            return ast.Ellipsis in actual_types
+        else:
+            raise RuntimeError('Unknown Constant value %r' % type(node.value))
+
+    return False

python_minifier-2.11.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Daniel Flook
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_minifier-2.11.2.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.1
+Name: python-minifier
+Version: 2.11.2
+Summary: Transform Python source code into it's most compact representation
+Home-page: https://github.com/dflook/python-minifier
+Author: Daniel Flook
+Author-email: daniel@flook.org
+License: MIT
+Project-URL: Documentation, https://dflook.github.io/python-minifier/
+Project-URL: Issues, https://github.com/dflook/python-minifier/issues
+Project-URL: Changelog, https://github.com/dflook/python-minifier/blob/main/CHANGELOG.md
+Keywords: minify minifier
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: 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
+Description-Content-Type: text/markdown
+
+# Python Minifier
+
+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.
+
+* [PyPI](https://pypi.org/project/python-minifier/)
+* [Documentation](https://dflook.github.io/python-minifier/)
+* [Issues](https://github.com/dflook/python-minifier/issues)
+
+As an example, the following python source:
+
+```python
+def handler(event, context):
+    l.info(event)
+    try:
+        i_token = hashlib.new('md5', (event['RequestId'] + event['StackId']).encode()).hexdigest()
+        props = event['ResourceProperties']
+
+        if event['RequestType'] == 'Create':
+            event['PhysicalResourceId'] = 'None'
+            event['PhysicalResourceId'] = create_cert(props, i_token)
+            add_tags(event['PhysicalResourceId'], props)
+            validate(event['PhysicalResourceId'], props)
+
+            if wait_for_issuance(event['PhysicalResourceId'], context):
+                event['Status'] = 'SUCCESS'
+                return send(event)
+            else:
+                return reinvoke(event, context)
+
+        elif event['RequestType'] == 'Delete':
+            if event['PhysicalResourceId'] != 'None':
+                acm.delete_certificate(CertificateArn=event['PhysicalResourceId'])
+            event['Status'] = 'SUCCESS'
+            return send(event)
+
+        elif event['RequestType'] == 'Update':
+
+            if replace_cert(event):
+                event['PhysicalResourceId'] = create_cert(props, i_token)
+                add_tags(event['PhysicalResourceId'], props)
+                validate(event['PhysicalResourceId'], props)
+
+                if not wait_for_issuance(event['PhysicalResourceId'], context):
+                    return reinvoke(event, context)
+            else:
+                if 'Tags' in event['OldResourceProperties']:
+                    acm.remove_tags_from_certificate(CertificateArn=event['PhysicalResourceId'],
+                                                     Tags=event['OldResourceProperties']['Tags'])
+
+                add_tags(event['PhysicalResourceId'], props)
+
+            event['Status'] = 'SUCCESS'
+            return send(event)
+        else:
+            raise RuntimeError('Unknown RequestType')
+
+    except Exception as ex:
+        l.exception('')
+        event['Status'] = 'FAILED'
+        event['Reason'] = str(ex)
+        return send(event)
+```
+
+Becomes:
+
+```python
+def handler(event,context):
+	L='OldResourceProperties';K='Tags';J='None';H='SUCCESS';G='RequestType';E='Status';D=context;B='PhysicalResourceId';A=event;l.info(A)
+	try:
+		F=hashlib.new('md5',(A['RequestId']+A['StackId']).encode()).hexdigest();C=A['ResourceProperties']
+		if A[G]=='Create':
+			A[B]=J;A[B]=create_cert(C,F);add_tags(A[B],C);validate(A[B],C)
+			if wait_for_issuance(A[B],D):A[E]=H;return send(A)
+			else:return reinvoke(A,D)
+		elif A[G]=='Delete':
+			if A[B]!=J:acm.delete_certificate(CertificateArn=A[B])
+			A[E]=H;return send(A)
+		elif A[G]=='Update':
+			if replace_cert(A):
+				A[B]=create_cert(C,F);add_tags(A[B],C);validate(A[B],C)
+				if not wait_for_issuance(A[B],D):return reinvoke(A,D)
+			else:
+				if K in A[L]:acm.remove_tags_from_certificate(CertificateArn=A[B],Tags=A[L][K])
+				add_tags(A[B],C)
+			A[E]=H;return send(A)
+		else:raise RuntimeError('Unknown RequestType')
+	except Exception as I:l.exception('');A[E]='FAILED';A['Reason']=str(I);return send(A)
+```
+
+## Why?
+
+AWS Cloudformation templates may have AWS lambda function source code embedded in them, but only if the function is less 
+than 4KiB. I wrote this package so I could write python normally and still embed the module in a template.
+
+## Installation
+
+To install python-minifier use pip:
+
+```bash
+$ pip install python-minifier
+```
+
+Note that python-minifier depends on the python interpreter for parsing source code,
+and outputs source code compatible with the version of the interpreter it is run with.
+
+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.
+
+## Usage
+
+To minify a source file, and write the minified module to stdout:
+
+```bash
+$ pyminify hello.py
+```
+
+There is also an API. The same example would look like:
+
+```python
+import python_minifier
+
+with open('hello.py') as f:
+    print(python_minifier.minify(f.read()))
+```
+
+Documentation is available at [dflook.github.io/python-minifier/](https://dflook.github.io/python-minifier/)
+
+## License
+
+Available under the MIT License. Full text is in the [LICENSE](LICENSE) file.
+
+Copyright (c) 2024 Daniel Flook
+
+

python_minifier-2.11.2.dist-info/RECORD

@@ -0,0 +1,44 @@
+python_minifier/__init__.py,sha256=mr0_t3hEk5R7K2fcidew9nys0PTBrEGKaPaizDEgWqk,9456
+python_minifier/__init__.pyi,sha256=_B0ywdLZ_iES6Ubq3ajuHbBS6Lr9J_InxJWbPo38iuQ,1214
+python_minifier/__main__.py,sha256=q2BU9CC5G328DFdfHmxg8auAwZTEc6pbM869p6583I4,11746
+python_minifier/ast_compare.py,sha256=ZxPTh7JwiuMo81e7jpOAnHsRAq7BXj3jCAeBu4K5kyI,3164
+python_minifier/ast_compat.py,sha256=ZOcHXNiIh9NFjFbLMndiewuT664ZtB_w0_AtlUV710Q,1620
+python_minifier/ast_printer.py,sha256=Nsh-8FM6-tsuLMfQBr9s32idQGnk8WZomJkJT_zLuAE,3222
+python_minifier/expression_printer.py,sha256=7r0Z0WDgYAaLwHg0STMNp70zSt4aVa45MJUGmTxxkqY,22423
+python_minifier/f_string.py,sha256=30cSPIzqQ7_oUX4UPWJWuXjWfPWWni9RWI85Qt_HisY,14036
+python_minifier/ministring.py,sha256=1J_nVWakRpW98yT706xe57mP0Rf45N1ivjAk7-AnOTA,4378
+python_minifier/module_printer.py,sha256=IXkvwC-EtPxNmzArGACqJhYF0sVX-rpHOxwSsoqFbYU,25342
+python_minifier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_minifier/token_printer.py,sha256=PKstW8JBpmk_C7S3t-SCx3nO-HStE1Ac3RxYl4XX_2g,9337
+python_minifier/util.py,sha256=hmMW4z8rTyO90b5cASxOVZyNGx_ohFWI5Pr4vAeodpo,1535
+python_minifier/rename/__init__.py,sha256=i-Su9VHxOwWGPMmURH1GUaFdtDZNYkKlbYdTUevgRi0,375
+python_minifier/rename/bind_names.py,sha256=TaR8VIjmKVRJvnMBjxbc52uTFVgS6OE9vm67i-mavJM,6941
+python_minifier/rename/binding.py,sha256=yOP3RFXzP7E0mVqdARNuWuKGmeqQyh42L8WhSXI51EE,15347
+python_minifier/rename/mapper.py,sha256=FU-rGFvd6N8vlTixWsEeNrQbL4ku9bldFJUL_O01EkU,6598
+python_minifier/rename/name_generator.py,sha256=70Klx2DteYRpBT8dr6jYDB31ARfinS42e08kKlWAzLg,1269
+python_minifier/rename/rename_literals.py,sha256=n_XHME6mhT9pR_RTiRjWo3YWvVuQoPNBERyCOgNrpBQ,7156
+python_minifier/rename/renamer.py,sha256=RitT7xFr8G1V3wQtxTvxgr1EXbQM6puUeK39CSUYtMo,6706
+python_minifier/rename/resolve_names.py,sha256=J3Yv32uc2KPfsTa-p9hUNNCEbQDDS-b0na6EUqVeGAo,4356
+python_minifier/rename/util.py,sha256=UchrXPibRr338POF-64zWRfl5OoxwUrE4uOnQstni2s,5451
+python_minifier/transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_minifier/transforms/combine_imports.py,sha256=rXbX8ygOMgDti1B_zwU5trEIRoDrGjUpQcC8VvQMioI,2298
+python_minifier/transforms/constant_folding.py,sha256=LWH2z210i9ZTFY8rgjEayifB7DPYkb6XSdHEQATurF4,4435
+python_minifier/transforms/remove_annotations.py,sha256=uBjka4wt22hPJQ66xpCj5B5HaFL3gZ6gr6OsGgq9yo4,4704
+python_minifier/transforms/remove_annotations_options.py,sha256=K-E9-TQlCyGRO-YKDfri0kyLevYxQweZhyViwiRAM7Y,1867
+python_minifier/transforms/remove_annotations_options.pyi,sha256=BUz465OPI88YKMpDLyLfPwiJ50sL0nBJtUf6Vot23Sc,575
+python_minifier/transforms/remove_asserts.py,sha256=jatGfsPeSzPuEHhTg9c6XaJRInM_t74zRmSEB1FoYYE,784
+python_minifier/transforms/remove_debug.py,sha256=2LoWJVZchhXx2O5rf1nou-_IlWkqYOu3_V5t2Wllly0,1856
+python_minifier/transforms/remove_exception_brackets.py,sha256=_-fQnjiiZCCkljC-GoG4XH9YzvRwQNfFy1KbA6_UG04,4110
+python_minifier/transforms/remove_explicit_return_none.py,sha256=1k4dzPneDPg9UJBKrj-b9YKDkyXlFVd9TzyuAjjzjSg,1287
+python_minifier/transforms/remove_literal_statements.py,sha256=dlYONJ-m5oj1zZITHsLY7O6QZ52rl1k2hHWbkqdxJNM,1619
+python_minifier/transforms/remove_object_base.py,sha256=MvI1XwwB9zcwdClhyTeoD6Won4VmzNdZZ0kcB4yBgt8,702
+python_minifier/transforms/remove_pass.py,sha256=A2c4psmYxQ6cYnk6u2KISZW6XhpDEaY-1zFx9Gy6RqI,781
+python_minifier/transforms/remove_posargs.py,sha256=ecLdKGr0kKx6uf7OXiB_SgF57xWRiDq6ixn5OBSVi7Y,330
+python_minifier/transforms/suite_transformer.py,sha256=zzQKf8QIVCHJ0IGF8i0yBi7kbyazaDQxrnu6eB4v6bg,6246
+python_minifier-2.11.2.dist-info/LICENSE,sha256=FzsyDHb8pAZupSGFjIOuHcHMlFf6N-aIxq9gOYGbNyE,1069
+python_minifier-2.11.2.dist-info/METADATA,sha256=OmFILwGLprKDfar9hQ6pN66fBekDGxIU7fUluDCXLZs,6453
+python_minifier-2.11.2.dist-info/WHEEL,sha256=1VPi6hfNQaRRNuEdK_3dv9o8COtLGnHWJghhj4CQ28k,92
+python_minifier-2.11.2.dist-info/entry_points.txt,sha256=aS7ZUWQeeys8lAbrmmEa2__Bg-anH1tUMyi9cKdTbO4,60
+python_minifier-2.11.2.dist-info/top_level.txt,sha256=4SRDfWKi_KMq7LDrjlzUFoDCs6INYPtxc1Pun4z8LsU,16
+python_minifier-2.11.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+python_minifier-2.11.2.dist-info/RECORD,,

python_minifier-2.11.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+

python_minifier-2.11.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pyminify = python_minifier.__main__:main
+

python_minifier-2.11.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+python_minifier

python_minifier-2.11.2.dist-info/zip-safe

@@ -0,0 +1 @@
+