traffic-taffy 0.5.8__py3-none-any.whl → 0.6.1__py3-none-any.whl

traffic_taffy/output/__init__.py

@@ -1,25 +1,40 @@
+"""Base module for output classes."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from traffic_taffy.comparison import Comparison
+
+
 class Output:
-    def __init__(self, report, options={}):
+    """Base class for outputting reports."""
+
+    def __init__(self, report: Comparison, options: dict | None = None):
+        """Initialize the base."""
         self.report = report
-        self.output_options = options
+        self.output_options = options or {}
 
     @property
-    def report(self):
+    def report(self) -> Comparison:
+        """The report itself."""
         return self._report
 
     @report.setter
-    def report(self, new_report):
+    def report(self, new_report: Comparison) -> None:
         self._report = new_report
 
     @property
-    def output_options(self):
+    def output_options(self) -> dict:
+        """A list of output options."""
         return self._output_options
 
     @output_options.setter
-    def output_options(self, new_output_options):
+    def output_options(self, new_output_options: dict) -> None:
         self._output_options = new_output_options
 
-    def output(self, report=None):
+    def output(self, report: Comparison | None = None) -> None:
+        """Dump a report to the output stream."""
         if not report:
             report = self.report
         contents = report.contents
@@ -55,12 +70,12 @@ class Output:
             ):
                 continue
 
-            # TODO: we don't do match_value here?
+            # TODO(hardaker): we don't do match_value here?
 
             record_count = 0
             for subkey, data in sorted(
                 contents[key].items(),
-                key=lambda x: x[1][sort_by],
+                key=lambda x: getattr(x[1], sort_by),
                 reverse=sort_order,
             ):
                 if not self.filter_check(data):
@@ -84,16 +99,18 @@ class Output:
 
         self.output_close()
 
-    def output_new_section(self, key):
+    def output_new_section(self, key: str) -> None:
+        """Create a new section header."""
         return
 
-    def output_close(self):
+    def output_close(self) -> None:
+        """Close the output stream."""
         return
 
     def filter_check(self, data: dict) -> bool:
-        "Return true if we should include it."
-        delta: float = data["delta_percentage"]
-        total: int = data["total"]
+        """Return true if we should include it."""
+        delta: float = data.delta_percentage
+        total: int = data.total
 
         if self.output_options["only_positive"] and delta <= 0:
             return False
@@ -122,12 +139,11 @@ class Output:
             # just check output_options["minimum_count"]
             if total > self.output_options["minimum_count"]:
                 return True
-        else:
+        elif (
+            total > self.output_options["minimum_count"]
+            and abs(delta) > self.output_options["print_threshold"]
+        ):
             # require both
-            if (
-                total > self.output_options["minimum_count"]
-                and abs(delta) > self.output_options["print_threshold"]
-            ):
-                return True
+            return True
 
         return False

traffic_taffy/output/console.py

@@ -1,21 +1,36 @@
+"""A module to output comparison results to the console."""
+
+from __future__ import annotations
+from typing import Dict, Any, TYPE_CHECKING
+from rich.console import Console as RichConsole
+
 from traffic_taffy.output import Output
 from traffic_taffy.dissection import Dissection
-from rich.console import Console as RichConsole
+
+if TYPE_CHECKING:
+    from traffic_taffy.comparison import Comparison
 
 
 class Console(Output):
-    def __init__(self, *args, **kwargs):
+    """An output class for reporting to a console."""
+
+    BOLD_LIMIT = 0.5
+    POSITIVE = 0.0
+
+    def __init__(self, *args: list, **kwargs: Dict[str, Any]):
+        """Create a console reporting object."""
         super().__init__(*args, **kwargs)
         self.console = None
         self.have_done_header = False
 
     # actual routines to print stuff
-    def init_console(self):
+    def init_console(self) -> None:
+        """Initialize the rich console object."""
         if not self.console:
             self.console = RichConsole()
 
-    def output_start(self, report):
-        "Prints the header about columns being displayed"
+    def output_start(self, report: Comparison) -> None:
+        """Print the header about columns being displayed."""
         # This should match the spacing in print_contents()
         self.init_console()
 
@@ -42,31 +57,31 @@ class Console(Output):
 
         self.console.print(line)
 
-    def output_new_section(self, key):
-        print(f"----- {key}")
-
-    def output_record(self, key, subkey, data) -> None:
-        "prints a report to the console"
+    def output_new_section(self, key: str) -> None:
+        """Print a new section border."""
+        self.console.print(f"----- {key}")
 
-        delta_percentage: float = data["delta_percentage"]
+    def output_record(self, key: str, subkey: Any, data: Dict[str, Any]) -> None:
+        """Print a report to the console."""
+        delta_percentage: float = data.delta_percentage
 
         # apply some fancy styling
         style = ""
-        if delta_percentage < -0.5:
+        if delta_percentage < -Console.BOLD_LIMIT:
             style = "[bold red]"
-        elif delta_percentage < 0.0:
+        elif delta_percentage < Console.POSITIVE:
             style = "[red]"
-        elif delta_percentage > 0.5:
+        elif delta_percentage > Console.BOLD_LIMIT:
             style = "[bold green]"
-        elif delta_percentage > 0.0:
+        elif delta_percentage > Console.POSITIVE:
             style = "[green]"
         endstyle = style.replace("[", "[/")
 
         # construct the output line with styling
         subkey = Dissection.make_printable(key, subkey)
         line = f"  {style}{subkey:<50}{endstyle}"
-        line += f" {data['left_count']:>8} {data['right_count']:>8} {data['delta_absolute']:>8}"
-        line += f" {100*data['left_percentage']:>7.2f} {100*data['right_percentage']:>7.2f}  {100*delta_percentage:>7.2f}"
+        line += f" {data.left_count:>8} {data.right_count:>8} {data.delta_absolute:>8}"
+        line += f" {100*data.left_percentage:>7.2f} {100*data.right_percentage:>7.2f}  {100*delta_percentage:>7.2f}"
 
         # print it to the rich console
         self.console.print(line)

traffic_taffy/output/fsdb.py

@@ -1,12 +1,18 @@
+"""A module to output comparison results to an FSDB output."""
 import sys
 import pyfsdb
+from typing import Any
 
 from traffic_taffy.output import Output
 from traffic_taffy.dissection import Dissection
+from traffic_taffy.comparison import Comparison
 
 
 class Fsdb(Output):
-    def __init__(self, *args, **kwargs):
+    """An FSDB report generator."""
+
+    def __init__(self, *args: list, **kwargs: dict):
+        """Create an FSDB report generator."""
         super().__init__(*args, **kwargs)
         self.console = None
         self.have_done_header = False
@@ -26,25 +32,24 @@ class Fsdb(Output):
         ]
         self.fsdb.converters = [str, str, str, int, int, int, float, float, float]
 
-    def output_start(self, report):
-        "Prints the header about columns being displayed"
+    def output_start(self, report: Comparison) -> None:
+        """Print the header about columns being displayed."""
         # This should match the spacing in print_contents()
         self.in_report = report.title
 
-    def output_record(self, key, subkey, data) -> None:
-        "prints a report to the console"
-
+    def output_record(self, key: str, subkey: Any, data: dict) -> None:
+        """Print a report to the console."""
         subkey = Dissection.make_printable(key, subkey)
         self.fsdb.append(
             [
                 self.in_report,
                 key,
                 subkey,
-                data["left_count"],
-                data["right_count"],
-                data["delta_absolute"],
-                data["left_percentage"],
-                data["right_percentage"],
-                data["delta_percentage"],
+                data.left_count,
+                data.right_count,
+                data.delta_absolute,
+                data.left_percentage,
+                data.right_percentage,
+                data.delta_percentage,
             ]
         )

traffic_taffy/output/memory.py

@@ -1,11 +1,17 @@
+"""Store contents of a report in memory."""
 from collections import defaultdict
+from typing import Any
 
 from traffic_taffy.output import Output
 from traffic_taffy.dissection import Dissection
+from traffic_taffy.comparison import Comparison
 
 
 class Memory(Output):
-    def __init__(self, *args, **kwargs):
+    """A class for storing report contents in memory."""
+
+    def __init__(self, *args: list, **kwargs: dict):
+        """Create a Memory object."""
         super().__init__(*args, **kwargs)
         self.console = None
         self.have_done_header = False
@@ -13,39 +19,40 @@ class Memory(Output):
         self.memory = None
 
     @property
-    def title(self):
+    def title(self) -> str:
+        """The title of the report."""
         return self._title
 
     @title.setter
-    def title(self, new_title):
+    def title(self, new_title: str) -> None:
         self._title = new_title
 
     @property
-    def memory(self):
+    def memory(self) -> dict:
+        """The data for the report."""
         return self._memory
 
     @memory.setter
-    def memory(self, new_memory):
+    def memory(self, new_memory: dict) -> None:
         self._memory = new_memory
 
-    def output_start(self, report):
-        "Prints the header about columns being displayed"
+    def output_start(self, report: Comparison) -> None:
+        """Print the header about columns being displayed."""
         # This should match the spacing in print_contents()
         self.title = report.title
         self.memory = defaultdict(list)
 
-    def output_record(self, key, subkey, data) -> None:
-        "prints a report to the console"
-
+    def output_record(self, key: str, subkey: Any, data: dict) -> None:
+        """Print a report to the console."""
         subkey = Dissection.make_printable(key, subkey)
         self.memory[key].append(
             {
                 "subkey": subkey,
-                "left_count": data["left_count"],
-                "right_count": data["right_count"],
-                "delta_absolute": data["delta_absolute"],
-                "left_percentage": data["left_percentage"],
-                "right_percentage": data["right_percentage"],
-                "delta_percentage": data["delta_percentage"],
+                "left_count": data.left_count,
+                "right_count": data.right_count,
+                "delta_absolute": data.delta_absolute,
+                "left_percentage": data.left_percentage,
+                "right_percentage": data.right_percentage,
+                "delta_percentage": data.delta_percentage,
             }
         )

traffic_taffy/tests/test_compare_results.py

@@ -1,5 +1,5 @@
 from collections import Counter
-from traffic_taffy.compare import PcapCompare
+from traffic_taffy.compare import PcapCompare, Report
 
 
 def test_compare_results():
@@ -9,42 +9,42 @@ def test_compare_results():
     # this should be positive when right_data is larger
     expected = {
         "src": {
-            "a": {
-                "total": 20,
-                "left_count": 5,
-                "right_count": 15,
-                "delta_absolute": 15 - 5,
-                "left_percentage": 5.0 / 15.0,
-                "right_percentage": 15.0 / 30.0,
-                "delta_percentage": 15.0 / 30.0 - 5.0 / 15.0,
-            },
-            "b": {
-                "total": -10,  # only in 1
-                "left_count": 10,
-                "right_count": 0,
-                "delta_absolute": 0 - 10,
-                "left_percentage": 10.0 / 15.0,
-                "right_percentage": 0.0,
-                "delta_percentage": -1.0,
-            },
-            "c": {
-                "total": 15,  # only in 2
-                "left_count": 0,
-                "right_count": 15,
-                "delta_absolute": 15 - 0,
-                "left_percentage": 0.0,
-                "right_percentage": 15.0 / 30.0,
-                "delta_percentage": 1.0,
-            },
-            "__NEW_VALUES__": {
-                "total": 2,  # 1 on each side
-                "left_count": 1,  # b
-                "right_count": 1,  # c
-                "delta_absolute": 1 - 1,
-                "left_percentage": 1.0 / 15.0,  # TODO: nuke this
-                "right_percentage": 1.0 / 30.0,  # TODO: nuke this
-                "delta_percentage": 1.0 / 30.0 - 1.0 / 15.0,
-            },
+            "a": Report(
+                total=20,
+                left_count=5,
+                right_count=15,
+                delta_absolute=15 - 5,
+                left_percentage=5.0 / 15.0,
+                right_percentage=15.0 / 30.0,
+                delta_percentage=15.0 / 30.0 - 5.0 / 15.0,
+            ),
+            "b": Report(
+                total=-10,  # only in 1
+                left_count=10,
+                right_count=0,
+                delta_absolute=0 - 10,
+                left_percentage=10.0 / 15.0,
+                right_percentage=0.0,
+                delta_percentage=-1.0,
+            ),
+            "c": Report(
+                total=15,  # only in 2
+                left_count=0,
+                right_count=15,
+                delta_absolute=15 - 0,
+                left_percentage=0.0,
+                right_percentage=15.0 / 30.0,
+                delta_percentage=1.0,
+            ),
+            "__NEW_VALUES__": Report(
+                total=2,  # 1 on each side
+                left_count=1,  # b
+                right_count=1,  # c
+                delta_absolute=1 - 1,
+                left_percentage=1.0 / 15.0,  # TODO: nuke this
+                right_percentage=1.0 / 30.0,  # TODO: nuke this
+                delta_percentage=1.0 / 30.0 - 1.0 / 15.0,
+            ),
         }
     }
 

traffic_taffy/tests/test_dpkt_engine.py

@@ -0,0 +1,15 @@
+import os
+from traffic_taffy.dissection import PCAPDissectorLevel
+from traffic_taffy.dissector_engine.dpkt import DissectionEngineDpkt
+
+def test_dpkt_engine():
+    test_pcap = "dns.pcap"
+    test_pcap = "port53-2023-30-31_20.pcap"
+    test_pcap = "airplane-wireless.pcap"
+    if not os.path.exists(test_pcap):
+        return
+
+    engine = DissectionEngineDpkt(test_pcap,
+                                  dissector_level = PCAPDissectorLevel.COMMON_LAYERS)
+    dissection = engine.load()
+

traffic_taffy/tests/test_pcap_dissector.py

@@ -4,7 +4,7 @@ from traffic_taffy.dissection import Dissection
 from traffic_taffy.dissector import PCAPDissector, PCAPDissectorLevel
 
 
-def test_dissector_load():
+def test_dissector_load() -> None:
     from traffic_taffy.dissector import PCAPDissector
 
     pd = PCAPDissector("bogus")
@@ -12,7 +12,7 @@ def test_dissector_load():
     assert pd.pcap_file == "bogus"
 
 
-def test_dissector_simple_callback():
+def test_dissector_simple_callback() -> None:
     base_pcap = "/tmp/dissector-test.pcap"  # doesn't need to exist
     save_file = base_pcap + ".taffy"
 
@@ -52,7 +52,7 @@ def test_dissector_simple_callback():
     # create a new one to make sure it's blank
     pd = PCAPDissector(
         base_pcap,
-        dissector_level=PCAPDissectorLevel.DETAILED.value,
+        dissector_level=PCAPDissectorLevel.COUNT_ONLY.value,
         cache_results=True,
     )
 
@@ -67,5 +67,5 @@ def test_dissector_simple_callback():
     os.unlink(save_file)
 
 
-def test_dissector_scapy_callback():
+def test_dissector_scapy_callback() -> None:
     assert True

traffic_taffy/tests/test_pcap_splitter.py

@@ -31,7 +31,6 @@ def test_pcap_splitter():
     ]:
         debug(f"===== trying to load {test_pcap} ====")
         if not os.path.exists(test_pcap):
-            print(f"a test requires a {test_pcap} file to read and parse")
             continue
 
         # clean up previous runs

traffic_taffy/tools/cache_info.py

@@ -1,13 +1,14 @@
-"""Loads the cached data for a file to display the results about it"""
+"""Loads the cached data for a file to display the results about it."""
 
-from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter, Namespace
+from pathlib import Path
 from rich import print
 import logging
 import msgpack
 
 
-def parse_args():
-    "Parse the command line arguments."
+def parse_args() -> Namespace:
+    """Parse the command line arguments."""
     parser = ArgumentParser(
         formatter_class=ArgumentDefaultsHelpFormatter,
         description=__doc__,
@@ -34,15 +35,17 @@ def parse_args():
     return args
 
 
-def main():
+def main() -> None:
+    """Run taffy-cache-info."""
     args = parse_args()
 
     for cache_file in args.cache_file:
         print(f"===== {cache_file} ======")
-        contents = msgpack.load(open(cache_file, "rb"), strict_map_key=False)
+        with Path(cache_file).open("rb") as fh:
+            contents = msgpack.load(fh, strict_map_key=False)
 
         # play the major keys
-        for key in contents.keys():
+        for key in contents:
             if key != "dissection" and key != "parameters":
                 print(f"{key:<20} {contents[key]}")
 

traffic_taffy/tools/compare.py

@@ -1,6 +1,7 @@
-"""Takes a set of pcap files to compare and creates a report"""
+"""Takes a set of pcap files to compare and creates a report."""
 
-from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+import sys
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter, Namespace
 import logging
 from traffic_taffy.output.console import Console
 from traffic_taffy.output.fsdb import Fsdb
@@ -14,8 +15,8 @@ from traffic_taffy.dissector import (
 from traffic_taffy.compare import PcapCompare
 
 
-def parse_args():
-    "Parse the command line arguments."
+def parse_args() -> Namespace:
+    """Parse the command line arguments."""
     parser = ArgumentParser(
         formatter_class=ArgumentDefaultsHelpFormatter,
         description=__doc__,
@@ -31,7 +32,7 @@ def parse_args():
     )
 
     limitor_parser = limitor_add_parseargs(parser)
-    compare_add_parseargs(limitor_parser, False)
+    compare_add_parseargs(limitor_parser, add_subgroup=False)
     dissector_add_parseargs(parser)
 
     debugging_group = parser.add_argument_group("Debugging options")
@@ -43,14 +44,6 @@ def parse_args():
         help="Define the logging verbosity level (debug, info, warning, error, ...).",
     )
 
-    parser.add_argument(
-        "-s",
-        "--sort-by",
-        default="delta%",
-        type=str,
-        help="Sort report entries by this column",
-    )
-
     parser.add_argument("pcap_files", type=str, nargs="*", help="PCAP files to analyze")
 
     args = parser.parse_args()
@@ -62,7 +55,8 @@ def parse_args():
     return args
 
 
-def main():
+def main() -> None:
+    """Run taffy-compare."""
     args = parse_args()
 
     # setup output options
@@ -88,7 +82,7 @@ def main():
             cache_file_suffix=args.cache_file_suffix,
             maximum_count=printing_arguments["maximum_count"],
             dissection_level=args.dissection_level,
-            between_times=args.between_times,
+            # between_times=args.between_times,  # TODO(hardaker): TBD
             bin_size=args.bin_size,
             ignore_list=args.ignore_list,
             pcap_filter=args.filter,
@@ -101,7 +95,7 @@ def main():
         try:
             reports = pc.compare()
         except ValueError:
-            exit()
+            sys.exit()
 
         if args.fsdb:
             output = Fsdb(None, printing_arguments)

traffic_taffy/tools/dissect.py

@@ -1,3 +1,5 @@
+"""Performs generic dissection of a PCAP file."""
+import logging
 from traffic_taffy.dissector import (
     dissector_add_parseargs,
     limitor_add_parseargs,
@@ -5,14 +7,14 @@ from traffic_taffy.dissector import (
     PCAPDissector,
 )
 from traffic_taffy.dissectmany import PCAPDissectMany
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter, Namespace
 
 
-def main():
-    from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
-    import logging
+def main() -> None:
+    """Dissect a pcap file and report contents."""
 
-    def parse_args():
-        "Parse the command line arguments."
+    def parse_args() -> Namespace:
+        """Parse the command line arguments."""
         parser = ArgumentParser(
             formatter_class=ArgumentDefaultsHelpFormatter,
             description=__doc__,
@@ -67,7 +69,7 @@ def main():
         force_overwrite=args.force_overwrite,
         force_load=args.force_load,
     )
-    dissections = pdm.load_all(True, dont_fork=args.dont_fork)
+    dissections = pdm.load_all(return_as_list=True, dont_fork=args.dont_fork)
 
     # merge them into a single dissection
     dissection = dissections.pop(0)