fix linters, remove astunparse dependency

Signed-off-by: William Woodruff <william@trailofbits.com>

Author: woodruffw

example/trace_binary.py

@@ -1,6 +1,5 @@
 import io
-
-from astunparse import unparse
+from ast import unparse
 
 import fickling.tracing as tracing
 from fickling.fickle import Interpreter, Pickled

fickling/analysis.py

@@ -1,23 +1,20 @@
+from __future__ import annotations
+
 import json
-import sys
 from abc import ABC, abstractmethod
+from ast import unparse
 from collections import defaultdict
+from collections.abc import Iterable, Iterator
 from enum import Enum
-from typing import Dict, Iterable, Iterator, List, Optional, Set, Tuple, Type
-
-if sys.version_info < (3, 9):
-    from astunparse import unparse
-else:
-    from ast import unparse
 
 from fickling.fickle import Interpreter, Pickled, Proto
 
 
 class AnalyzerMeta(type):
-    _DEFAULT_INSTANCE: Optional["Analyzer"] = None
+    _DEFAULT_INSTANCE: Analyzer | None = None
 
     @property
-    def default_instance(cls) -> "Analyzer":
+    def default_instance(cls) -> Analyzer:
         if cls._DEFAULT_INSTANCE is None:
             cls._DEFAULT_INSTANCE = Analyzer(Analysis.ALL)
         return cls._DEFAULT_INSTANCE
@@ -26,11 +23,11 @@ def default_instance(cls) -> "Analyzer":
 class AnalysisContext:
     def __init__(self, pickled: Pickled):
         self.pickled: Pickled = pickled
-        self.reported_shortened_code: Set[str] = set()
-        self.previous_results: List[AnalysisResult] = []
-        self.results_by_analysis: Dict[Type[Analysis], List[AnalysisResult]] = defaultdict(list)
+        self.reported_shortened_code: set[str] = set()
+        self.previous_results: list[AnalysisResult] = []
+        self.results_by_analysis: dict[type[Analysis], list[AnalysisResult]] = defaultdict(list)
 
-    def analyze(self, analysis: "Analysis") -> "List[AnalysisResult]":
+    def analyze(self, analysis: Analysis) -> list[AnalysisResult]:
         results = list(analysis.analyze(self))
         if not results:
             self.results_by_analysis[type(analysis)].append(AnalysisResult(Severity.LIKELY_SAFE))
@@ -40,10 +37,10 @@ def analyze(self, analysis: "Analysis") -> "List[AnalysisResult]":
         return results
 
     @property
-    def results(self) -> "AnalysisResults":
+    def results(self) -> AnalysisResults:
         return AnalysisResults(pickled=self.pickled, results=self.previous_results)
 
-    def shorten_code(self, ast_node) -> Tuple[str, bool]:
+    def shorten_code(self, ast_node) -> tuple[str, bool]:
         code = unparse(ast_node).strip()
         if len(code) > 32:
             cutoff = code.find("(")
@@ -59,10 +56,10 @@ def shorten_code(self, ast_node) -> Tuple[str, bool]:
 
 
 class Analyzer(metaclass=AnalyzerMeta):
-    def __init__(self, analyses: Iterable["Analysis"]):
-        self.analyses: Tuple[Analysis, ...] = tuple(analyses)
+    def __init__(self, analyses: Iterable[Analysis]):
+        self.analyses: tuple[Analysis, ...] = tuple(analyses)
 
-    def analyze(self, pickled: Pickled) -> "AnalysisResults":
+    def analyze(self, pickled: Pickled) -> AnalysisResults:
         context = AnalysisContext(pickled=pickled)
         for a in self.analyses:
             context.analyze(a)
@@ -101,14 +98,14 @@ class AnalysisResult:
     def __init__(
         self,
         severity: Severity,
-        message: Optional[str] = None,
+        message: str | None = None,
         analysis_name: str = None,
-        trigger: Optional[str] = None,
+        trigger: str | None = None,
     ):
         self.severity: Severity = severity
-        self.message: Optional[str] = message
+        self.message: str | None = message
         self.analysis_name: str = analysis_name
-        self.trigger: Optional[str] = trigger  # Field to store the trigger code fragment or artifact
+        self.trigger: str | None = trigger  # Field to store the trigger code fragment or artifact
 
     def __lt__(self, other):
         return isinstance(other, AnalysisResult) and (
@@ -127,7 +124,7 @@ def __str__(self):
 
 
 class Analysis(ABC):
-    ALL: "List[Analysis]" = []
+    ALL: list[Analysis] = []
 
     def __init_subclass__(cls, **kwargs):
         Analysis.ALL.append(cls())
@@ -140,7 +137,7 @@ def analyze(self, context: AnalysisContext) -> Iterator[AnalysisResult]:
 class DuplicateProtoAnalysis(Analysis):
     def analyze(self, context: AnalysisContext) -> Iterator[AnalysisResult]:
         had_proto = False
-        proto_versions: Set[int] = set()
+        proto_versions: set[int] = set()
         for i, opcode in enumerate(context.pickled):
             if isinstance(opcode, Proto):
                 if had_proto:
@@ -344,7 +341,7 @@ def analyze(self, context: AnalysisContext) -> Iterator[AnalysisResult]:
 class AnalysisResults:
     def __init__(self, pickled: Pickled, results: Iterable[AnalysisResult]):
         self.pickled: Pickled = pickled
-        self.results: Tuple[AnalysisResult, ...] = tuple(results)
+        self.results: tuple[AnalysisResult, ...] = tuple(results)
 
     @property
     def severity(self) -> Severity:
@@ -356,7 +353,7 @@ def __bool__(self):
         """Returns True if all analyses failed to find any unsafe operations"""
         return all(map(bool, sorted(self.results)))
 
-    def detailed_results(self) -> Dict[str, Dict[str, str]]:
+    def detailed_results(self) -> dict[str, dict[str, str]]:
         detailed = defaultdict(dict)
         for result in self.results:
             if result.trigger:
@@ -386,9 +383,9 @@ def to_dict(self, verbosity: Severity = Severity.POSSIBLY_UNSAFE):
 
 def check_safety(
     pickled: Pickled,
-    analyzer: Optional[Analyzer] = None,
+    analyzer: Analyzer | None = None,
     verbosity: Severity = Severity.POSSIBLY_UNSAFE,
-    json_output_path: Optional[str] = None,
+    json_output_path: str | None = None,
 ) -> AnalysisResults:
     if analyzer is None:
         analyzer = Analyzer.default_instance

fickling/cli.py

@@ -1,19 +1,16 @@
+from __future__ import annotations
+
 import sys
 from argparse import ArgumentParser
-from typing import List, Optional
-
-if sys.version_info >= (3, 9):
-    from ast import unparse
-else:
-    from astunparse import unparse
+from ast import unparse
 
 from . import __version__, fickle, tracing
 from .analysis import Severity, check_safety
 
 DEFAULT_JSON_OUTPUT_FILE = "safety_results.json"
 
 
-def main(argv: Optional[List[str]] = None) -> int:
+def main(argv: list[str] | None = None) -> int:
     if argv is None:
         argv = sys.argv