traffic-taffy 0.3.6__py3-none-any.whl → 0.4.1__py3-none-any.whl

pcap_compare/graph.py

@@ -1,210 +0,0 @@
-"""Read a PCAP file and graph it or parts of it"""
-
-import os
-import seaborn as sns
-import matplotlib.pyplot as plt
-import pandas
-from pandas import DataFrame, to_datetime
-from pcap_compare.dissector import (
-    PCAPDissectorType,
-    dissector_add_parseargs,
-    limitor_add_parseargs,
-    check_dissector_level,
-)
-from pcap_compare.dissectmany import PCAPDissectMany, PCAPDissector
-
-from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
-from logging import debug, info
-import logging
-
-
-def parse_args():
-    "Parse the command line arguments."
-    parser = ArgumentParser(
-        formatter_class=ArgumentDefaultsHelpFormatter,
-        description=__doc__,
-        epilog="Exmaple Usage: ",
-    )
-
-    parser.add_argument(
-        "-g",
-        "--graph-elements",
-        default=None,
-        type=str,
-        help="Graph these particular elements; the default is packet counts",
-    )
-
-    parser.add_argument(
-        "-o",
-        "--output-file",
-        default=None,
-        type=str,
-        help="Where to save the output (png)",
-    )
-
-    parser.add_argument(
-        "--log-level",
-        "--ll",
-        default="info",
-        help="Define verbosity level (debug, info, warning, error, fotal, critical).",
-    )
-
-    parser.add_argument(
-        "-b",
-        "--bin-size",
-        type=int,
-        default=1,
-        help="Bin results into this many seconds",
-    )
-
-    dissector_add_parseargs(parser)
-    limitor_add_parseargs(parser)
-
-    parser.add_argument("input_file", type=str, help="PCAP file to graph", nargs="+")
-
-    args = parser.parse_args()
-    log_level = args.log_level.upper()
-    logging.basicConfig(level=log_level, format="%(levelname)-10s:\t%(message)s")
-    logging.getLogger("matplotlib.font_manager").setLevel(logging.ERROR)
-    return args
-
-
-class PcapGraph:
-    def __init__(
-        self,
-        pcap_files: str,
-        output_file: str,
-        maximum_count: int = None,
-        minimum_count: int = None,
-        bin_size: int = None,
-        match_key: str = None,
-        match_value: str = None,
-        cache_pcap_results: bool = False,
-        dissector_level: PCAPDissectorType = PCAPDissectorType.COUNT_ONLY,
-    ):
-        self.pcap_files = pcap_files
-        self.output_file = output_file
-        self.maximum_count = maximum_count
-        self.minimum_count = minimum_count
-        self.bin_size = bin_size
-        self.subsections = None
-        self.pkt_filter = None
-        self.match_key = match_key
-        self.match_value = match_value
-        self.cache_pcap_results = cache_pcap_results
-        self.dissector_level = dissector_level
-
-    def load_pcaps(self):
-        "loads the pcap and counts things into bins"
-        self.data = {}
-
-        info("reading pcap files")
-        pdm = PCAPDissectMany(
-            self.pcap_files,
-            bin_size=self.bin_size,
-            maximum_count=self.maximum_count,
-            dissector_level=self.dissector_level,
-            pcap_filter=self.pkt_filter,
-            cache_results=self.cache_pcap_results,
-        )
-        results = pdm.load_all()
-
-        for result in results:
-            self.data[result["file"]] = result["data"]
-        info("done reading pcap files")
-
-    def normalize_bins(self, counters):
-        results = {}
-        time_keys = list(counters.keys())
-        if time_keys[0] == 0:  # likely always
-            time_keys.pop(0)
-        time_keys[0]
-        time_keys[-1]
-
-        results = {"time": [], "count": [], "index": []}
-
-        # TODO: this could likely be made much more efficient and needs hole-filling
-        info(f"match value: {self.match_value}")
-        for (timestamp, key, subkey, value) in PCAPDissector.find_data(
-            counters,
-            timestamps=time_keys,
-            match_string=self.match_key,
-            match_value=self.match_value,
-            minimum_count=self.minimum_count,
-            make_printable=True,
-        ):
-            index = key + "=" + subkey
-            results["count"].append(int(value))
-            results["index"].append(index)
-            results["time"].append(timestamp)
-
-        return results
-
-    def merge_datasets(self):
-        datasets = []
-        for dataset in self.data:
-            data = self.normalize_bins(self.data[dataset])
-            data = DataFrame.from_records(data)
-            data["filename"] = os.path.basename(dataset)
-            data["time"] = to_datetime(data["time"], unit="s")
-            datasets.append(data)
-        datasets = pandas.concat(datasets)
-        return datasets
-
-    def create_graph(self):
-        "Graph the results of the data collection"
-        debug("creating the graph")
-        sns.set_theme()
-
-        df = self.merge_datasets()
-        debug(df)
-
-        hue_variable = "index"
-        if df[hue_variable].nunique() == 1:
-            hue_variable = None
-
-        ax = sns.relplot(
-            data=df,
-            kind="line",
-            x="time",
-            y="count",
-            hue=hue_variable,
-            aspect=1.77,
-        )
-        ax.set(xlabel="time", ylabel="count")
-        plt.xticks(rotation=45)
-
-        info(f"saving graph to {self.output_file}")
-        if self.output_file:
-            plt.savefig(self.output_file)
-        else:
-            plt.show()
-
-    def graph_it(self):
-        debug("--- loading pcaps")
-        self.load_pcaps()
-        debug("--- creating graph")
-        self.create_graph()
-
-
-def main():
-    args = parse_args()
-
-    check_dissector_level(args.dissection_level)
-
-    pc = PcapGraph(
-        args.input_file,
-        args.output_file,
-        maximum_count=args.packet_count,
-        minimum_count=args.minimum_count,
-        bin_size=args.bin_size,
-        match_key=args.match_string,
-        match_value=args.match_value,
-        cache_pcap_results=args.cache_pcap_results,
-        dissector_level=args.dissection_level,
-    )
-    pc.graph_it()
-
-
-if __name__ == "__main__":
-    main()

traffic_taffy/explore.py

@@ -1,221 +0,0 @@
-import sys
-import logging
-from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
-from traffic_taffy.dissector import (
-    dissector_add_parseargs,
-    limitor_add_parseargs,
-    check_dissector_level,
-)
-from traffic_taffy.graphdata import PcapGraphData
-from traffic_taffy.compare import PcapCompare
-from PyQt6.QtCharts import QLineSeries, QChart, QChartView
-
-# https://stackoverflow.com/questions/32476006/how-to-make-an-expandable-collapsable-section-widget-in-qt
-
-# class Widget(QWidget):
-#     def __init__(self):
-#         super().__init__()
-#         self.__initUi()
-
-#     def __initUi(self):
-#         addBtn = QPushButton('Add')
-#         addBtn.clicked.connect(self.__add)
-#         self.__foldableListWidget = FoldableListWidget()
-#         lay = QVBoxLayout()
-#         lay.addWidget(addBtn)
-#         lay.addWidget(self.__foldableListWidget)
-#         self.setLayout(lay)
-
-#     def __add(self):
-#         foldedItem = QLabel("folded")
-# #        foldedItem.setPlaceholderText('Input...')
-
-#         sublist = FoldableListWidget()
-#         subitem1 = QLabel("main item")
-#         subitem2 = QLabel("sub item")
-#         sublist.setFoldableListWidgetItem(subitem1, subitem2)
-
-#         self.__foldableListWidget.setFoldableListWidgetItem(foldedItem, sublist)
-
-
-from PyQt6.QtWidgets import (
-    QPushButton,
-    QDialog,
-    QGridLayout,
-    QVBoxLayout,
-    QHBoxLayout,
-    QApplication,
-    QWidget,
-)
-
-
-class TaffyExplorer(QDialog, PcapGraphData):
-    """Explore PCAP files by comparison slices"""
-
-    def __init__(self, args):
-        super().__init__()
-
-        # TODO: allow varying
-        self.minimum_count = 2
-
-        self.mainLayout = QVBoxLayout()
-        self.setLayout(self.mainLayout)
-
-        # create the graph at the top
-        self.detail_graph = QChart()
-        self.detail_graph_view = QChartView(self.detail_graph)
-        self.mainLayout.addWidget(self.detail_graph_view)
-
-        # create the mini graph next
-        self.traffic_graph = QChart()
-        self.traffic_graph.legend().hide()
-        self.traffic_graph.setTitle("All Traffic")
-        self.traffic_graph_view = QChartView(self.traffic_graph)
-        self.mainLayout.addWidget(self.traffic_graph_view)
-
-        # create the traffic source menu bar
-        self.source_menus = QHBoxLayout()  # TODO: line graph
-        self.source_menus_w = QWidget()
-        self.source_menus_w.setLayout(self.source_menus)
-        self.mainLayout.addWidget(self.source_menus_w)
-
-        # the comparison panel contains deltas between them
-        self.comparison_panel = QGridLayout()
-        self.comparison_panel_w = QWidget()
-        self.comparison_panel_w.setLayout(self.comparison_panel)
-        self.mainLayout.addWidget(self.comparison_panel_w)
-
-        self.quit_button = QPushButton("Quit")
-        self.mainLayout.addWidget(self.quit_button)
-        self.quit_button.clicked.connect(self.quit)
-
-        # self.tree = QTreeWidget()
-        # self.tree.setHeaderHidden(True)
-        # self.tree.setIndentation(0)
-
-        self.args = args
-
-    def quit(self):
-        exit()
-
-    def create_comparison(self):
-        self.pc = PcapCompare(
-            self.args.pcap_files,
-            maximum_count=self.args.packet_count,
-            print_threshold=float(self.args.print_threshold) / 100.0,
-            print_minimum_count=self.args.minimum_count,
-            print_match_string=self.args.match_string,
-            only_positive=self.args.only_positive,
-            only_negative=self.args.only_negative,
-            cache_results=self.args.cache_pcap_results,
-            dissection_level=self.args.dissection_level,
-            between_times=self.args.between_times,
-            bin_size=self.args.bin_size,
-        )
-
-        # create the graph data storage
-        # and load everything in
-        datasets = list(self.pc.load_pcaps())
-
-        self.data = {}
-        for dataset in datasets:
-            self.data[dataset["file"]] = dataset["data"]
-
-    def update_chart(
-        self, chart: QChart, match_key: str, match_value: str | None = None
-    ):
-        self.match_key = match_key
-        self.match_value = match_value
-
-        df = self.merge_datasets()
-
-        series = QLineSeries()
-
-        # TODO: there must be a better way!
-        for index in df.index:
-            series.append(
-                df["time"][index].to_pydatetime().timestamp(), df["count"][index]
-            )
-
-        chart.addSeries(series)
-
-    def update_detail_chart(
-        self, match_key: str = "__TOTAL__", match_value: str | None = None
-    ):
-        self.update_chart(self.detail_graph, match_key, match_value)
-
-    def update_traffic_chart(self):
-        self.update_chart(self.traffic_graph, "__TOTAL__")
-
-    # def show_comparison(self, pcap_one, timestamp_one, pcap_two, timestamp_two):
-
-
-def parse_args():
-    "Parse the command line arguments."
-    parser = ArgumentParser(
-        formatter_class=ArgumentDefaultsHelpFormatter,
-        description=__doc__,
-        epilog="Exmaple Usage: ",
-    )
-
-    limiting_parser = limitor_add_parseargs(parser)
-
-    limiting_parser.add_argument(
-        "-t",
-        "--print-threshold",
-        default=0.0,
-        type=float,
-        help="Don't print results with abs(percent) less than this threshold",
-    )
-
-    limiting_parser.add_argument(
-        "-P", "--only-positive", action="store_true", help="Only show positive entries"
-    )
-
-    limiting_parser.add_argument(
-        "-N", "--only-negative", action="store_true", help="Only show negative entries"
-    )
-
-    limiting_parser.add_argument(
-        "-T",
-        "--between-times",
-        nargs=2,
-        type=int,
-        help="For single files, only display results between these timestamps",
-    )
-
-    dissector_add_parseargs(parser)
-
-    debugging_group = parser.add_argument_group("Debugging options")
-
-    debugging_group.add_argument(
-        "--log-level",
-        "--ll",
-        default="info",
-        help="Define the logging verbosity level (debug, info, warning, error, ...).",
-    )
-
-    parser.add_argument("pcap_files", type=str, nargs="+", help="PCAP files to analyze")
-
-    args = parser.parse_args()
-    log_level = args.log_level.upper()
-    logging.basicConfig(level=log_level, format="%(levelname)-10s:\t%(message)s")
-
-    check_dissector_level(args.dissection_level)
-
-    return args
-
-
-def main():
-    args = parse_args()
-
-    app = QApplication(sys.argv)
-    window = TaffyExplorer(args)
-    window.create_comparison()
-    window.update_traffic_chart()
-    window.show()
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    main()

traffic_taffy-0.3.6.dist-info/RECORD

@@ -1,22 +0,0 @@
-pcap_compare/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pcap_compare/cache_info.py,sha256=22Fs5fNU_GzWwcAua_XfEFswRmlM8TmTbHXe2CYKQDE,1468
-pcap_compare/compare.py,sha256=xVRNmCsdUp1mEZub0SN2CW7osOZMgJuW__Cj9UA2DRE,9169
-pcap_compare/dissectmany.py,sha256=dxxChV0Qq9LeoPXiS0cCIEKFtO_RJwHxwOoPOZ3rwU8,681
-pcap_compare/dissector.py,sha256=iEZzLHJ7HubM3-UbZR461irXkZcpM8u_Aoa7GzWUMEY,17571
-pcap_compare/dissectorresults.py,sha256=LKoyX04Qjc6B7RnqtJgIWsyVnselJ9CygLkMAp3lhw0,647
-pcap_compare/graph.py,sha256=cioVq9JYNRVqzlRJSKLveGnGSEL9FkXDUyp-Y7osSkM,5935
-traffic_taffy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-traffic_taffy/cache_info.py,sha256=zpuuJcPzJzyma37YJE4FwKSaOBAmzImDj0Khdn2x1FI,1623
-traffic_taffy/compare.py,sha256=IDcO2rzYoVs_9NrUTF5TaJHzrETOw0eheu98vu_h8O4,12359
-traffic_taffy/dissectmany.py,sha256=DDz2Kv_0TIuSRwb2jgl2ffHEHWhwTrnhkIyzDH8pJvA,2514
-traffic_taffy/dissector.py,sha256=qYsSGTuxT0bYy5WW1EZaAua2guPBetEjunJk-ZMTVWU,21484
-traffic_taffy/dissectorresults.py,sha256=LKoyX04Qjc6B7RnqtJgIWsyVnselJ9CygLkMAp3lhw0,647
-traffic_taffy/explore.py,sha256=O4C5X9yKUbu0LZNKcBhwpEEoLomHWH7MqMUm2ike_Lc,6595
-traffic_taffy/graph.py,sha256=-fluyt-REEIzM9h3uoExrJT0K5s1LUTdcHllrr_quoM,4952
-traffic_taffy/graphdata.py,sha256=mXzRWAReV_oDfnRIVlxqaOCk5nZKZ07mutHPdnX5eeA,1583
-traffic_taffy/pcap_splitter.py,sha256=qDZ0Nd81fIteQRVElyKsD1ncBi4lg07cmx8KPl_q3rY,4585
-traffic_taffy-0.3.6.dist-info/METADATA,sha256=qC5mASfshWYRXyplqLMoE_yxAUdyx_H2CVn77cw118k,1014
-traffic_taffy-0.3.6.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-traffic_taffy-0.3.6.dist-info/entry_points.txt,sha256=xabsmMHgr0Pek8ccdQoW6iAKqljueozDZW-q1hJ79eU,194
-traffic_taffy-0.3.6.dist-info/top_level.txt,sha256=wjeQaxXSKqUzrRtfbUlbSn8SoaL4VC73yudFAEtnIuo,14
-traffic_taffy-0.3.6.dist-info/RECORD,,

traffic_taffy-0.3.6.dist-info/entry_points.txt

@@ -1,5 +0,0 @@
-[console_scripts]
-taffy-cache-info = traffic_taffy.cache_info:main
-taffy-compare = traffic_taffy.compare:main
-taffy-dissect = traffic_taffy.dissector:main
-taffy-graph = traffic_taffy.graph:main