def comparator(self, asns=None): js_name = config.get("web", "canvas_comparator_name") if asns is None: pass else: splitted_asns = asns.split() g = GraphGenerator(js_name) title = "" for asn in splitted_asns: if asn.isdigit(): self.report.prepare_graphe_js(asn) # as_graph_infos : [ipv4, ipv6, dates, first_date, last_date] as_graph_infos = self.report.graph_infos g.add_line( [as_graph_infos[0], as_graph_infos[2]], asn + " IPv4", as_graph_infos[3], as_graph_infos[4] ) g.add_line( [as_graph_infos[1], as_graph_infos[2]], asn + " IPv6", as_graph_infos[3], as_graph_infos[4] ) title += asn + " " if len(g.lines) > 0: g.set_title(title) g.make_js() self.js = g.js self.js_name = js_name else: self.js = self.js_name = None
def comparator(self, asns = None): """ Get the data needed to display the page of the comparator FIXME: rewrite it!! """ js_name = self.config.get('web','canvas_comparator_name') asns_to_return = [] if asns is not None: splitted_asns = asns.split() g = GraphGenerator(js_name) title = '' for asn in splitted_asns: if asn.isdigit(): asns_to_return.append(asn) graph_last_date = datetime.date.today() graph_first_date = datetime.date.today() - datetime.timedelta(days=self.days_graph) graph_dates = self.report.get_dates_from_interval(graph_first_date, graph_last_date) dates_sources = self.report.get_all_sources(graph_dates) all_ranks = self.report.get_all_ranks(asn, graph_dates, dates_sources) data_graph, last_seen_sources = self.report.prepare_graphe_js(all_ranks, graph_dates, dates_sources) g.add_line(data_graph, str(asn + self.report.ip_key), graph_dates) title += asn + ' ' if len(g.lines) > 0: g.set_title(title) g.make_js() self.js = g.js self.js_name = js_name else: self.js = self.js_name = None return " ".join(asns_to_return)
def make_graph(self, infos): js_name = config.get('web','canvas_asn_name') g = GraphGenerator(js_name) g.add_line(infos, self.report.ip_key, self.graph_first_date, self.graph_last_date ) g.set_title(self.asn) g.make_js() self.js = g.js self.js_name = js_name
def make_graph(self, infos): js_name = config.get("web", "canvas_asn_name") g = GraphGenerator(js_name) g.add_line([infos[0], infos[2]], "IPv4", infos[3], infos[4]) g.add_line([infos[1], infos[2]], "IPv6", infos[3], infos[4]) g.set_title(self.asn) g.make_js() self.js = g.js self.js_name = js_name
def make_graph(self, asn, infos): """ Generate the graph with the data provided by the model """ js_name = self.config.get('web','canvas_asn_name') g = GraphGenerator(js_name) graph_last_date = datetime.date.today() graph_first_date = datetime.date.today() - datetime.timedelta(days=self.days_graph) graph_dates = self.report.get_dates_from_interval(graph_first_date, graph_last_date) g.add_line(infos, self.report.ip_key, graph_dates) g.set_title(asn) g.make_js() self.js = g.js self.js_name = js_name
def get_stats(self): """ Get data to diaplay on the RGraph graph """ stats = self.report.get_stats() dates = self.get_dates() lines = [] g = GraphGenerator('canvas_stats') for date in dates: line = self.report.prepare_distrib_graph(date) sorted_label = sorted(line.keys()) g.add_line(line, date, sorted_label[3:-1]) g.set_title("stats") g.make_js() return stats, g.js, 'canvas_stats'
def get_test_result(filename, full_graph=False, chain_graph=False): columns = [ 'Count of nodes', 'BFS average time', 'BFS delta time', 'BFS memory', 'DFS average time', 'DFS delta time', 'DFS memory', 'Dijkstra average time', 'Dijkstra delta time', 'Dijkstra memory', 'Ford-Bellman average time', 'Ford-Bellman delta time', 'Ford-Bellman memory', 'A_Star average time', 'A_Star delta time', 'A_Star memory' ] with open(filename, 'w', newline='') as file: writer = csv.DictWriter(file, dialect=csv.excel_tab(), fieldnames=columns) writer.writeheader() tester = Tester() for i in range(NUMBER_OF_TESTS): if not chain_graph: start_node = random.randint(0, NODE_COUNT + STEP * i - 1) finish_node = random.randint(0, NODE_COUNT + STEP * i - 1) else: start_node = 0 finish_node = NODE_COUNT + STEP * i - 1 base_graph_generator = GraphGenerator(NODE_COUNT + STEP * i, False, False, full_graph, chain_graph) graph = base_graph_generator.generate_graph() weighted_ordered_graph_generator = GraphGenerator( NODE_COUNT + STEP * i, True, True, full_graph, chain_graph) weighted_graph = weighted_ordered_graph_generator.generate_graph() negative_weighted_graph_generator = GraphGenerator( NODE_COUNT + STEP * i, True, True, full_graph, chain_graph, negative_weighted=True) negative_weighted_graph = ( negative_weighted_graph_generator.generate_graph()) planar_graph_generator = GraphGenerator(NODE_COUNT + STEP * i, True, True, chain_graph=chain_graph, planar=True) planar_graph = planar_graph_generator.generate_graph() result_line = tester.get_test_line(NODE_COUNT + STEP * i, start_node, finish_node, graph, weighted_graph, planar_graph, negative_weighted_graph) writer.writerow(result_line)
def test_generate_unweighted_ordered_graph(self): graph_generator = GraphGenerator(3, False, True) graph = graph_generator.generate_graph() self.assertIsInstance(graph, UnweightedOrderedGraph)
def test_generate_weighted_unordered_graph(self): graph_generator = GraphGenerator(3, True, False) graph = graph_generator.generate_graph() self.assertIsInstance(graph, WeightedUnorderedGraph)
import networkx as nx from matplotlib import pyplot as plt from graph_node import Node from vector import Vector from math import atan2 from graph_generator import GraphGenerator from graph import Graph graph_generator = GraphGenerator() graph1 = graph_generator.generate_circular(15, 15, 3 * 15 - 6, 3 * 15 - 6, 50) nx_graph1 = graph1.get_nx_graph() graph_generator.remove_random_edges(3, 7) graph_generator.change_all_nodes_position(2) graph2 = graph_generator.graph nx_graph2 = graph2.get_nx_graph() node1, node2, node3, node4 = Node(0, 10, 10), Node(1, 10, 20), Node(2, 20, 20), Node(3, 20, 10) # graph = Graph([node1, node2, node3, node4], [(0, 1), (1, 2), (2, 3), (3, 0)]) # nx_graph1.add_node(node1.index, pos=(node1.x, node1.y)) # nx_graph1.add_node(node2.index, pos=(node2.x, node2.y)) # nx_graph1.add_node(node3.index, pos=(node3.x, node3.y)) # nx_graph1.add_node(node4.index, pos=(node4.x, node4.y)) # nx_graph1.add_edge(1, 2) # nx_graph1.add_edge(2, 3) # nx_graph1.add_edge(3, 4)
from graph_generator import GraphGenerator import csv import imdb if __name__ == "__main__": id_list = [] ia = imdb.IMDb() with open('actors_id.csv', newline='') as csvfile: for row in csv.reader(csvfile, delimiter=','): id_list.append(row[0]) graph = GraphGenerator(id_list[:10], ia).generate() graph.save()
def setUp(self): self.g = GraphGenerator()
def test_is_tree(self): graph = {'1': ['2', '3'], '2': ['3'], '3': ['1'], '4': []} self.assertFalse(GraphGenerator.is_tree(graph)) graph = {'1': ['2', '3'], '2': ['1'], '3': ['4', '1'], '4': ['3']} self.assertTrue(GraphGenerator.is_tree(graph))
class MainWindow(QMainWindow): '''window for visualizing and controlling graphs''' def __init__(self, parent=None) -> None: super().__init__(parent) self.setWindowTitle("Graph App") self.renderer = GraphRender() self.setCentralWidget(self.renderer) # set up graph generator and renderer self.graphGen = GraphGenerator() self.graphGen.area_w = self.renderer.area_w self.graphGen.area_h = self.renderer.area_h self.graph = self.graphGen.genGraph() self.renderer.setGraph(self.graph) self.newGraph() # set up menus and bars file_menu = self.menuBar().addMenu("&File") file_menu.addAction("&New") file_menu.addAction("&Save") file_menu.addAction("&Load") file_menu.addAction("E&xit", self.close) view_menu = self.menuBar().addMenu("&View") view_menu.addAction("Voronoi &Background", self.renderer.drawBackground) toolBar = self.createToolBar() toolBar.setOrientation(Qt.Vertical) self.addToolBar(Qt.RightToolBarArea, toolBar) statusBar = QStatusBar() statusBar.showMessage("Status Bar! More down to earth than Space Bar.") self.setStatusBar(statusBar) def createToolBar(self) -> QToolBar: toolBar = QToolBar(self) toolBar.addAction("New Graph", self.newGraph) toolBar.addSeparator() toolBar.addWidget(QLabel("Node generator:")) nodeStratBox = QComboBox(toolBar) nodeStratBox.addItems(self.graphGen.nodeStrategyList) nodeStratBox.currentIndexChanged.connect(self.setNewNodeStrategy) nodeStratBox.setCurrentIndex(self.graphGen.nodeStrategy) toolBar.addWidget(nodeStratBox) toolBar.addWidget(QLabel("\nEdge generator:")) edgeStratBox = QComboBox(toolBar) edgeStratBox.addItems(self.graphGen.edgeStrategyList) edgeStratBox.currentIndexChanged.connect(self.setNewEdgeStrategy) edgeStratBox.setCurrentIndex(self.graphGen.edgeStrategy) toolBar.addWidget(edgeStratBox) toolBar.addSeparator() toolBar.addWidget(QLabel("Generator settings", toolBar)) self.regionNumberX = QSpinBox() self.regionNumberX.setRange(1, 100) self.regionNumberX.setValue(self.graphGen.numberOfRegionsX) self.regionNumberX.valueChanged.connect(self.setNumberOfRegionsX) self.regionNumberY = QSpinBox() self.regionNumberY.setRange(1, 100) self.regionNumberY.setValue(self.graphGen.numberOfRegionsY) self.regionNumberY.valueChanged.connect(self.setNumberOfRegionsY) self.nodeNumber = QSpinBox() self.nodeNumber.setRange(1, 100) self.nodeNumber.setValue(self.graphGen.numberOfNodes) self.nodeNumber.valueChanged.connect(self.setNumberOfNodes) self.edgeChance = QSpinBox() self.edgeChance.setRange(0, 100) self.edgeChance.setValue(self.graphGen.connection_chance) self.edgeChance.valueChanged.connect(self.setConnectionChance) graphGrid = QGridLayout() graphGrid.setColumnMinimumWidth(0, 20) graphGrid.setColumnMinimumWidth(1, 30) graphGrid.addWidget(QLabel("Regions X:")) graphGrid.addWidget(self.regionNumberX) graphGrid.addWidget(QLabel("Regions Y:")) graphGrid.addWidget(self.regionNumberY) graphGrid.addWidget(QLabel("Node number:")) graphGrid.addWidget(self.nodeNumber) graphGrid.addWidget(QLabel("Edge forming\nchance:")) graphGrid.addWidget(self.edgeChance) graphGridHolder = QWidget() graphGridHolder.setLayout(graphGrid) toolBar.addWidget(graphGridHolder) toolBar.addSeparator() toolBar.addAction("Exit", self.close) return toolBar def newGraph(self): self.graph = self.graphGen.genGraph() #self.graph.highlighted_node = graph_methods.breadth_first(self.graph, self.graph.nodes[0]) #graph_methods.highlightComponents(self.graph) graph_methods.highlightSpanningTree(self.graph) self.renderer.repaint() def setNewNodeStrategy(self, index: int): self.graphGen.nodeStrategy = index def setNewEdgeStrategy(self, index: int): self.graphGen.edgeStrategy = index def setNumberOfNodes(self, value: int): self.graphGen.numberOfNodes = value if value <= 10: self.renderer.pixel_size = 32 elif value <= 20: self.renderer.pixel_size = 16 elif value <= 40: self.renderer.pixel_size = 8 elif value <= 80: self.renderer.pixel_size = 4 else: self.renderer.pixel_size = 2 def setConnectionChance(self, value: int): self.graphGen.connection_chance = value def setNumberOfRegionsX(self, value: int): self.graphGen.numberOfRegionsX = value def setNumberOfRegionsY(self, value: int): self.graphGen.numberOfRegionsY = value
def test_family_graph1(self): attrs = { 'get_person_main.side_effect': self.get_person_main, 'get_movie.side_effect': self.get_movie } ia = MagicMock(**attrs) graph = GraphGenerator(self.actor_ids, ia, max_threads=4).generate() self.assertEqual(None, graph.get_edge("Maxim", "Lilia")) self.assertEqual({"Sumy"}, graph.get_edge("Maxim", "Kostya")) self.assertEqual({"Sumy"}, graph.get_edge("Kostya", "Maxim")) self.assertEqual({"Moscow"}, graph.get_edge("Kostya", "Svetlana")) self.assertEqual({"Moscow"}, graph.get_edge("Kostya", "Elena")) self.assertEqual({"Moscow"}, graph.get_edge("Kostya", "Lilia")) self.assertEqual({"Moscow"}, graph.get_edge("Lilia", "Svetlana")) self.assertEqual({"Moscow", "Budapest"}, graph.get_edge("Lilia", "Elena")) self.assertEqual({"Moscow"}, graph.get_edge("Lilia", "Kostya")) self.assertEqual({"Moscow"}, graph.get_edge("Svetlana", "Lilia")) self.assertEqual({"Moscow", "New York"}, graph.get_edge("Svetlana", "Elena")) self.assertEqual({"Moscow"}, graph.get_edge("Svetlana", "Kostya")) self.assertEqual({"New York"}, graph.get_edge("Svetlana", "Irina")) self.assertEqual({"Moscow", "Budapest"}, graph.get_edge("Elena", "Lilia")) self.assertEqual({"Moscow", "New York"}, graph.get_edge("Elena", "Svetlana")) self.assertEqual({"Moscow"}, graph.get_edge("Elena", "Kostya")) self.assertEqual({"New York"}, graph.get_edge("Elena", "Irina")) self.assertEqual({"New York"}, graph.get_edge("Irina", "Elena")) self.assertEqual({"New York"}, graph.get_edge("Irina", "Svetlana"))
number_of_pattern_vertices, number_of_pattern_edges, number_of_pattern_vertex_labels, number_of_pattern_edge_labels) graph_generators = list() for p in range(CONFIG["number_of_patterns"]): pattern = ig.read( os.path.join(save_pattern_dir, patterns_id + "_%d.gml" % (p))) pattern.vs["label"] = [ int(x) for x in pattern.vs["label"] ] pattern.es["label"] = [ int(x) for x in pattern.es["label"] ] pattern.es["key"] = [int(x) for x in pattern.es["key"]] graph_generators.append(GraphGenerator(pattern)) for alpha in CONFIG["alphas"]: for number_of_graph_vertices in CONFIG[ "number_of_graph_vertices"]: if number_of_graph_vertices < number_of_pattern_vertices: continue for number_of_graph_vertex_labels in CONFIG[ "number_of_graph_vertex_labels"]: if number_of_graph_vertex_labels > number_of_graph_vertices: continue if number_of_graph_vertex_labels < number_of_pattern_vertex_labels: continue for number_of_graph_edges in CONFIG[ "number_of_graph_edges"]: if number_of_graph_edges < number_of_graph_vertices - 1: # not connected continue
from event_finder import EventFinder from graph_generator import GraphGenerator from graph_traverser import GraphTraverser from input_parser import Parser from possibilities import Possibilities from state_node import StateNode parser = Parser() startNodeSet = parser.parseStartNodes() adjList = parser.parseReachability() vulnDict, portDict = parser.parseVulnerabilities() eventMapping = parser.parseEventMapping() eventSet = EventFinder() # Generate attack graph graphGenerator = GraphGenerator(startNodeSet, adjList, vulnDict, portDict) DG = graphGenerator.generate_graph() timestamp, src, dst, port, description, accessLevel = parser.parseNotableEvent( ) graphTraverser = GraphTraverser(DG, eventSet, eventMapping, portDict.keys()) eventSequence = graphTraverser.start_traversal(timestamp, src, dst, port, description, accessLevel) # Print possibilities crownJewelSet = parser.parseCrownJewels() possibilitiesGenerator = Possibilities() notableEventStateNode = StateNode(dst, accessLevel) possibilitiesGenerator.printPossiblePaths(DG, notableEventStateNode, crownJewelSet)