unidecompiler-plugin-python-pyc 0.1.2__tar.gz → 0.1.4__tar.gz

{unidecompiler_plugin_python_pyc-0.1.2 → unidecompiler_plugin_python_pyc-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unidecompiler-plugin-python-pyc
-Version: 0.1.2
+Version: 0.1.4
 Summary: Python bytecode frontend plugin for unidecompiler
 Author-email: Wker <1670133844@qq.com>
 License-Expression: AGPL-3.0-or-later
@@ -9,7 +9,7 @@ Project-URL: Repository, https://github.com/Wker666/unidecompiler
 Project-URL: Issues, https://github.com/Wker666/unidecompiler/issues
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: unidecompiler<0.2.0,>=0.1.2
+Requires-Dist: unidecompiler<0.2.0,>=0.1.9
 
 # unidecompiler-plugin-python-pyc
 

{unidecompiler_plugin_python_pyc-0.1.2 → unidecompiler_plugin_python_pyc-0.1.4}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unidecompiler-plugin-python-pyc"
-version = "0.1.2"
+version = "0.1.4"
 description = "Python bytecode frontend plugin for unidecompiler"
 readme = "README.md"
 license = "AGPL-3.0-or-later"
 authors = [{ name = "Wker", email = "1670133844@qq.com" }]
 requires-python = ">=3.11"
-dependencies = ["unidecompiler>=0.1.2,<0.2.0"]
+dependencies = ["unidecompiler>=0.1.9,<0.2.0"]
 
 [project.urls]
 Homepage = "https://github.com/Wker666/unidecompiler"

{unidecompiler_plugin_python_pyc-0.1.2 → unidecompiler_plugin_python_pyc-0.1.4}/src/unidecompiler_plugin_python_pyc/lifter.py

@@ -13,6 +13,10 @@ from unidecompiler.core.effects import (
     BuildArrayCall,
     CallTopAs,
     Copy,
+    DeleteAttr,
+    DeleteGlobal,
+    DeleteItem,
+    DeleteLocal,
     DropBelowTop,
     Effect,
     Compare,
@@ -32,14 +36,17 @@ from unidecompiler.core.effects import (
     Iterate,
     MakeFunctionValue,
     MergeMap,
+    OfferImplicitCallArguments,
     Pop,
     Push,
     RaiseTop,
     RaiseWithCause,
     ReraiseTop,
+    ResumeValue,
     ReturnTop,
     ReturnVoid,
     StoreAttr,
+    StoreGlobal,
     StoreLocal,
     StoreMany,
     StoreManyFromPopOrder,
@@ -55,7 +62,6 @@ from unidecompiler.core.effects import (
 )
 from unidecompiler.core.vm_module import assemble_vm_module
 from unidecompiler.core.ir import (
-    Assign,
     BinaryOp,
     CapturedVar,
     Const,
@@ -83,15 +89,13 @@ from unidecompiler.provenance import ByteRange
 from unidecompiler.core.vm_region import (
     VMLinearState,
     VMRegionCallbacks,
+    VMRegionSlice,
     VMRegionOpcodeClasses,
     VMRegionProfile,
     VMStatefulCallbacks,
     build_hint_region_profile,
     lift_control_region as lift_vm_control_region,
 )
-from unidecompiler.core.vm_structures import (
-    vm_unsupported,
-)
 from unidecompiler_plugin_python_pyc.pyc import PycCodeObject, PycExceptionRegion, PycModule
 
 
@@ -102,6 +106,10 @@ BINARY_SYMBOLS = {
     "-=": "-",
     "*": "*",
     "*=": "*",
+    "**": "**",
+    "**=": "**",
+    "@": "@",
+    "@=": "@",
     "/": "/",
     "/=": "/",
     "//": "//",
@@ -122,7 +130,6 @@ BINARY_SYMBOLS = {
 COMPLEX_OPS = {
 }
 IGNORED_OPS = {
-    "RESUME",
     "CACHE",
     "NOP",
     "EXTENDED_ARG",
@@ -130,7 +137,7 @@ IGNORED_OPS = {
     "COPY_FREE_VARS",
 }
 PYTHON_REGION_OPCODE_CLASSES = VMRegionOpcodeClasses(
-    noise=frozenset({"END_FOR", "POP_TOP", "NOP", "RESUME"}),
+    noise=frozenset({"END_FOR", "POP_TOP", "NOP"}),
     control=frozenset(
         {
             "POP_JUMP_IF_FALSE",
@@ -190,8 +197,7 @@ def _load_build_class(_context, _instruction, source: SourceRef) -> tuple[Effect
 
 def _import_name(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
     return (
-        Pop(source=source, count=2, allow_missing=True),
-        Push(source=source, value=Global(name=str(instruction.argval), source=source)),
+        BuildCall(source=source, callee=Global(name=f"__import__:{instruction.argval}", source=source), arg_count=2, returns=1),
     )
 
 
@@ -219,6 +225,14 @@ def _load_local(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
     return (LoadLocal(source=source, name=name, fallback=Var(name=name, source=source)),)
 
 
+def _load_and_clear_local(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    name = str(instruction.argval)
+    return (
+        LoadLocal(source=source, name=name, fallback=Var(name=name, source=source)),
+        DeleteLocal(source=source, name=name),
+    )
+
+
 def _load_closure(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
     name = str(instruction.argval)
     return (Push(source=source, value=CapturedVar(name=name, source=source)),)
@@ -243,12 +257,25 @@ def _load_global(_context, instruction, source: SourceRef) -> tuple[Effect, ...]
 
 def _load_from_dict_or_globals(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
     name = str(instruction.argval)
+    return (BuildCall(source=source, callee=Global(name=f"load_from_dict_or_globals:{name}", source=source), arg_count=1, returns=1),)
+
+
+def _call_intrinsic_1(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    return (CallTopAs(source=source, callee_name=str(instruction.argval or instruction.argrepr or "intrinsic")),)
+
+
+def _before_with(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    name = "before_async_with" if "ASYNC" in instruction.opname else "before_with"
     return (
-        Pop(source=source, count=1, allow_missing=True),
-        Push(source=source, value=Global(name=name, source=source)),
+        BuildCall(source=source, callee=Global(name=name, source=source), arg_count=1, returns=1),
+        Unpack(source=source, count=2),
     )
 
 
+def _set_function_attribute(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    return (BuildCall(source=source, callee=Global(name=f"set_function_attribute:{instruction.argval or instruction.argrepr}", source=source), arg_count=2, returns=1),)
+
+
 def _make_function(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
     return (MakeFunctionValue(source=source, fallback_name=str(instruction.argval or instruction.argrepr or "<function>")),)
 
@@ -283,7 +310,10 @@ def _build_set(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
 
 
 def _get_iter(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
-    return (Iterate(source=source),)
+    return (
+        Iterate(source=source),
+        OfferImplicitCallArguments(source=source, max_explicit_arg_count=0),
+    )
 
 
 def _unpack_sequence(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
@@ -321,7 +351,7 @@ def _unary(op: str):
 
 def _store_global(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
     name = str(instruction.argval)
-    return (StoreLocal(source=source, name=name, target=Var(name=name, source=source), materialize=False),)
+    return (StoreGlobal(source=source, name=name),)
 
 
 def _store_deref(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
@@ -336,16 +366,32 @@ def _store_deref(_context, instruction, source: SourceRef) -> tuple[Effect, ...]
     )
 
 
-def _delete_global(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
-    return (Pop(source=source, count=1, allow_missing=True),)
+def _delete_local(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    name = str(instruction.argval)
+    return (DeleteLocal(source=source, name=name),)
 
 
-def _delete_attr(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
-    return (Pop(source=source, count=1, allow_missing=True),)
+def _delete_deref(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    name = str(instruction.argval)
+    return (
+        DeleteLocal(
+            source=source,
+            name=name,
+            target=CapturedVar(name=name, source=source),
+        ),
+    )
+
+
+def _delete_global(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    return (DeleteGlobal(source=source, name=str(instruction.argval)),)
+
+
+def _delete_attr(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    return (DeleteAttr(source=source, attr=str(instruction.argval)),)
 
 
 def _delete_subscr(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
-    return (Pop(source=source, count=2, allow_missing=True),)
+    return (DeleteItem(source=source),)
 
 
 def _build_slice(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
@@ -360,7 +406,10 @@ def _binary_slice(_context, _instruction, source: SourceRef) -> tuple[Effect, ..
 
 
 def _store_slice(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
-    return (StoreItemEffect(source=source),)
+    return (
+        BuildCall(source=source, arg_count=2, callee=Global(name="slice", source=source)),
+        StoreItemEffect(source=source, order="value-obj-key"),
+    )
 
 
 def _list_extend(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
@@ -443,8 +492,8 @@ def _map_add(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
     return (StoreItemAtDepth(source=source, depth=_instruction_count(instruction)),)
 
 
-def _set_add(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
-    return (SetAdd(source=source),)
+def _set_add(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    return (SetAdd(source=source, depth=_instruction_count(instruction)),)
 
 
 def _store_local(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
@@ -484,6 +533,13 @@ def _yield_value(_context, instruction, source: SourceRef) -> tuple[Effect, ...]
     return (YieldTop(source=source, default=Const(value=None, source=source)),)
 
 
+def _resume(_context, instruction, source: SourceRef) -> tuple[Effect, ...]:
+    # CPython's resume mode 5 continues a ``yield`` expression, whose value
+    # is supplied by the caller.  Await/send modes manage their result in the
+    # surrounding protocol and must not manufacture an extra stack value.
+    return (ResumeValue(source=source),) if _instruction_count(instruction) == 5 else ()
+
+
 def _send(_context, _instruction, source: SourceRef) -> tuple[Effect, ...]:
     return (Pop(source=source, count=1, allow_missing=True),)
 
@@ -521,24 +577,17 @@ PYTHON_EFFECT_TABLE = VMEffectTable(
         "JUMP_NO_INTERRUPT",
         "INSTRUMENTED_JUMP_BACKWARD",
         "INSTRUMENTED_JUMP_FORWARD",
-        "CALL_INTRINSIC_1",
-        "BEFORE_WITH",
         "CLEANUP_THROW",
         "CHECK_EG_MATCH",
         "END_ASYNC_FOR",
         "LOOKUP_METHOD",
         "PUSH_EXC_INFO",
         "WITH_EXCEPT_START",
-        "DELETE_FAST",
-        "DELETE_NAME",
-        "DELETE_DEREF",
-        "DELETE_GLOBAL",
         "ENTER_EXECUTOR",
         "EXIT_INIT_CHECK",
         "INSTRUMENTED_INSTRUCTION",
         "INSTRUMENTED_LINE",
         "INSTRUMENTED_RESUME",
-        "INTERPRETER_EXIT",
         "POP_BLOCK",
         "RESERVED",
         "SETUP_CLEANUP",
@@ -559,12 +608,15 @@ PYTHON_EFFECT_TABLE = VMEffectTable(
         "LOAD_CLOSURE": _load_closure,
         "LOAD_FAST": _load_local,
         "LOAD_FAST_CHECK": _load_local,
-        "LOAD_FAST_AND_CLEAR": _load_local,
+        "LOAD_FAST_AND_CLEAR": _load_and_clear_local,
         "LOAD_FAST_LOAD_FAST": _load_fast_pair,
         "LOAD_FROM_DICT_OR_GLOBALS": _load_from_dict_or_globals,
         "LOAD_GLOBAL": _load_global,
         "MAKE_FUNCTION": _make_function,
         "STORE_GLOBAL": _store_global,
+        "DELETE_FAST": _delete_local,
+        "DELETE_NAME": _delete_local,
+        "DELETE_DEREF": _delete_deref,
         "DELETE_GLOBAL": _delete_global,
         "DELETE_ATTR": _delete_attr,
         "DELETE_SUBSCR": _delete_subscr,
@@ -577,7 +629,12 @@ PYTHON_EFFECT_TABLE = VMEffectTable(
         "CALL_FUNCTION_EX": _call_function_ex,
         "INSTRUMENTED_CALL_FUNCTION_EX": _call_function_ex,
         "LOAD_LOCALS": _load_locals,
-        "SET_FUNCTION_ATTRIBUTE": lambda _context, _instruction, source: (DropBelowTop(source=source, count=1),),
+        "SET_FUNCTION_ATTRIBUTE": _set_function_attribute,
+        "CALL_INTRINSIC_1": _call_intrinsic_1,
+        "BEFORE_WITH": _before_with,
+        "BEFORE_ASYNC_WITH": _before_with,
+        "EXIT_INIT_CHECK": lambda _context, _instruction, source: (BuildCall(source=source, callee=Global(name="exit_init_check", source=source), arg_count=1, returns=0),),
+        "INTERPRETER_EXIT": lambda _context, _instruction, source: (ReturnTop(source=source),),
         "COPY": _copy,
         "SWAP": _swap,
         "LOAD_ATTR": _load_attr,
@@ -605,6 +662,7 @@ PYTHON_EFFECT_TABLE = VMEffectTable(
         "BUILD_TUPLE": _build_tuple,
         "BUILD_SET": _build_set,
         "SET_ADD": _set_add,
+        "RESUME": _resume,
         "GET_ITER": _get_iter,
         "GET_YIELD_FROM_ITER": _get_iter,
         "UNPACK_SEQUENCE": _unpack_sequence,
@@ -684,8 +742,8 @@ def lift_code_object(code: PycCodeObject) -> FunctionIR:
         _python_function_spec(code),
         steps,
         profile=_python_region_profile(steps, instructions),
-        callbacks=_python_region_callbacks(code, instructions),
-        stateful_callbacks=_python_stateful_callbacks(code, instructions),
+        callbacks_factory=lambda normalized_steps: _python_region_callbacks(code, normalized_steps),
+        stateful_callbacks_factory=lambda normalized_steps: _python_stateful_callbacks(code, normalized_steps),
         initial_locals=_python_initial_locals(code),
         raw_window=lambda index: _raw_instruction_window(instructions, index),
     )
@@ -884,21 +942,40 @@ def _python_initial_locals(code: PycCodeObject) -> dict[str, Expr]:
 
 def _python_region_callbacks(
     code: PycCodeObject,
-    instructions: tuple[object, ...],
+    prepared_steps: tuple[VMBytecodeStep, ...],
 ) -> VMRegionCallbacks[VMBytecodeStep]:
+    def lift_slice(slice_start, slice_end, stack):
+        slice_steps = prepared_steps[slice_start:slice_end]
+        result = lift_steps(
+            slice_steps,
+            initial_locals=_python_initial_locals(code),
+            initial_stack=stack,
+        )
+        if result.state.diagnostics:
+            return VMRegionSlice(stopped_at=slice_start)
+        output: list[object] = list(result.state.statements)
+        if result.stopped_at is not None and result.state.terminator is None:
+            return VMRegionSlice(
+                statements=tuple(output),
+                stopped_at=slice_start + slice_steps.index(result.stopped_at),
+            )
+        if result.state.terminator is not None:
+            output.append(result.state.terminator)
+        return VMRegionSlice(statements=tuple(output))
+
+    def lift_expr(slice_start, slice_end, stack):
+        result = lift_steps(
+            prepared_steps[slice_start:slice_end],
+            initial_locals=_python_initial_locals(code),
+            initial_stack=stack,
+        )
+        if result.state.diagnostics or not result.state.stack:
+            return None
+        return result.state.stack[-1]
+
     return VMRegionCallbacks(
-        lift_slice=lambda slice_start, slice_end, stack: _lift_instruction_slice(
-            code,
-            instructions[slice_start:slice_end],
-            [],
-            stack,
-        ),
-        lift_expr=lambda slice_start, slice_end, stack: _lift_stack_expr(
-            code,
-            instructions[slice_start:slice_end],
-            [],
-            stack,
-        ),
+        lift_slice=lift_slice,
+        lift_expr=lift_expr,
         lift_iter_loop=lambda _get_iter_index, _iterable: None,
         lift_async_iter_loop=lambda _prefix_start, _get_aiter_index, _region_end: None,
         lift_comprehension=lambda _prefix_start, _get_iter_index, _region_end, _iterable: None,
@@ -907,45 +984,38 @@ def _python_region_callbacks(
 
 def _python_stateful_callbacks(
     code: PycCodeObject,
-    instructions: tuple[object, ...],
+    prepared_steps: tuple[VMBytecodeStep, ...],
 ) -> VMStatefulCallbacks[VMBytecodeStep]:
+    def lift_linear(start, end, locals_, stack):
+        slice_steps = prepared_steps[start:end]
+        result = lift_steps(
+            slice_steps,
+            initial_locals=locals_,
+            initial_stack=stack,
+        )
+        stopped_at_terminal_end = (
+            result.stopped_at is slice_steps[-1]
+            if slice_steps and result.state.terminator is not None
+            else False
+        )
+        if result.state.diagnostics or (
+            result.stopped_at is not None and not stopped_at_terminal_end
+        ):
+            return None
+        return VMLinearState(
+            locals=result.state.locals,
+            stack=tuple(result.state.stack),
+            statements=tuple(result.state.statements),
+            terminator=result.state.terminator,
+        )
+
     return VMStatefulCallbacks(
         initial_locals=lambda: _python_initial_locals(code),
-        lift_linear=lambda start, end, locals, stack: _python_linear_state(
-            instructions[start:end],
-            locals,
-            stack,
-        ),
+        lift_linear=lift_linear,
         branch_condition=_python_branch_condition,
     )
 
 
-def _python_linear_state(
-    instructions: tuple[object, ...],
-    initial_locals: dict[str, Expr],
-    initial_stack: tuple[Expr, ...],
-) -> VMLinearState | None:
-    result = _run_python_stack_slice(
-        _PycLinearLocals(tuple(initial_locals)),
-        instructions,
-        dict(initial_locals),
-        initial_stack,
-    )
-    stopped_at_terminal_end = (
-        getattr(result.stopped_at, "source", None) == _python_source(instructions[-1])
-        if instructions and result.state.terminator is not None
-        else False
-    )
-    if result.state.diagnostics or (result.stopped_at is not None and not stopped_at_terminal_end):
-        return None
-    return VMLinearState(
-        locals=result.state.locals,
-        stack=tuple(result.state.stack),
-        statements=tuple(result.state.statements),
-        terminator=result.state.terminator,
-    )
-
-
 def _python_branch_condition(branch: VMBytecodeStep, stack: tuple[Expr, ...]) -> Expr | None:
     if not stack:
         return None
@@ -962,11 +1032,6 @@ def _python_branch_condition(branch: VMBytecodeStep, stack: tuple[Expr, ...]) ->
     return condition
 
 
-class _PycLinearLocals:
-    def __init__(self, varnames: tuple[str, ...]) -> None:
-        self.varnames = varnames
-
-
 def _python_region_profile(
     steps: tuple[VMBytecodeStep, ...],
     instructions: tuple[object, ...],
@@ -999,70 +1064,6 @@ def _await_region_end(instructions: tuple[object, ...], start: int, end: int) ->
     return None
 
 
-def _lift_instruction_slice(
-    code: PycCodeObject,
-    instructions: tuple[object, ...],
-    assignments: list[Assign],
-    preloaded_stack: tuple[Expr, ...] = (),
-) -> tuple[object, ...]:
-    if not instructions:
-        return ()
-    initial_locals = {
-        name: Var(name=name, source=SourceRef(frontend="python-pyc", detail=f"local:{name}"))
-        for name in code.varnames
-    }
-    for assignment in assignments:
-        initial_locals[assignment.target.name] = assignment.target
-    result = _run_python_stack_slice(code, instructions, initial_locals, preloaded_stack)
-    if result.state.diagnostics:
-        return ()
-    output: list[object] = list(result.state.statements)
-    if result.stopped_at is not None and result.state.terminator is None:
-        try:
-            stopped_index = instructions.index(result.stopped_at)
-        except ValueError:
-            stopped_index = 0
-        output.append(
-            vm_unsupported(
-                source=result.stopped_at.source,
-                message="unsupported region",
-                detail=f"stopped at {result.stopped_at.opcode}",
-                raw=(result.stopped_at.raw,) if result.stopped_at.raw else _raw_instruction_window(instructions, stopped_index),
-            )
-        )
-    if result.state.terminator is not None:
-        output.append(result.state.terminator)
-    return tuple(output)
-
-
-def _lift_stack_expr(
-    code: PycCodeObject,
-    instructions: tuple[object, ...],
-    assignments: list[Assign],
-    preloaded_stack: tuple[Expr, ...] = (),
-) -> Expr | None:
-    initial_locals = {
-        name: Var(name=name, source=SourceRef(frontend="python-pyc", detail=f"local:{name}"))
-        for name in code.varnames
-    }
-    for assignment in assignments:
-        initial_locals[assignment.target.name] = assignment.target
-    result = _run_python_stack_slice(code, instructions, initial_locals, preloaded_stack)
-    if result.state.diagnostics or not result.state.stack:
-        return None
-    return result.state.stack[-1]
-
-
-def _run_python_stack_slice(
-    code: PycCodeObject,
-    instructions: tuple[object, ...],
-    initial_locals: dict[str, Expr],
-    initial_stack: tuple[Expr, ...] = (),
-):
-    steps = _python_bytecode_steps(instructions)
-    return lift_steps(steps, initial_locals=initial_locals, initial_stack=initial_stack)
-
-
 def _instruction_count(instruction) -> int:
     return instruction.arg if isinstance(instruction.arg, int) else 0
 

{unidecompiler_plugin_python_pyc-0.1.2 → unidecompiler_plugin_python_pyc-0.1.4}/src/unidecompiler_plugin_python_pyc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unidecompiler-plugin-python-pyc
-Version: 0.1.2
+Version: 0.1.4
 Summary: Python bytecode frontend plugin for unidecompiler
 Author-email: Wker <1670133844@qq.com>
 License-Expression: AGPL-3.0-or-later
@@ -9,7 +9,7 @@ Project-URL: Repository, https://github.com/Wker666/unidecompiler
 Project-URL: Issues, https://github.com/Wker666/unidecompiler/issues
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: unidecompiler<0.2.0,>=0.1.2
+Requires-Dist: unidecompiler<0.2.0,>=0.1.9
 
 # unidecompiler-plugin-python-pyc
 

unidecompiler_plugin_python_pyc-0.1.4/src/unidecompiler_plugin_python_pyc.egg-info/requires.txt

@@ -0,0 +1 @@
+unidecompiler<0.2.0,>=0.1.9

unidecompiler_plugin_python_pyc-0.1.2/src/unidecompiler_plugin_python_pyc.egg-info/requires.txt

@@ -1 +0,0 @@
-unidecompiler<0.2.0,>=0.1.2