def compute_graph(edges, x, y, precision, tollerance): if booldebug: print(x, y) graph = Graph('image') q = Queue('nodes') p_node = Point(x, y) node = Node(p_node) graph.nodes.append(node) q.push(node) while not q.empty(): node = q.top() q.pop() links = [] p_node = node.get_point() x = p_node.get_x() y = p_node.get_y() cell = generate_cell(edges, p_node, precision) links = find_lines(cell, edges, x - precision, y - precision, tollerance) #if booldebug: print(links) delete(edges, cell, x - precision, y - precision) for p in links: graph.nodes.append(Node(p)) q.push(Node(p)) graph.manage_links(node, links) if len(graph.nodes) > 2: return DPS(graph)
def compile(self, input_file_path, output_file_path, rendering_function=None): dsl_file = open(input_file_path) current_parent = self.root for token in dsl_file: token = token.replace(" ", "").replace("\n", "") if token.find(self.opening_tag) != -1: token = token.replace(self.opening_tag, "") element = Node(token, current_parent, self.content_holder) current_parent.add_child(element) current_parent = element elif token.find(self.closing_tag) != -1: current_parent = current_parent.parent else: tokens = token.split(",") for t in tokens: element = Node(t, current_parent, self.content_holder) current_parent.add_child(element) output_html = self.root.render(self.dsl_mapping, rendering_function=rendering_function) with open(output_file_path, 'w') as output_file: output_file.write(output_html)
def compile(self, input_file_path, output_file_path, rendering_function=None): dsl_file = open(input_file_path) current_parent = self.root i = 0 for token in dsl_file: token = token.replace(" ", "").replace('\t', '').replace("\n", "") if token.find(self.opening_tag) != -1: token = token.replace(self.opening_tag, "") element = Node(token, current_parent, self.content_holder, getID(i)) current_parent.add_child(element) current_parent = element i += 1 elif token.find(self.closing_tag) != -1: current_parent = current_parent.parent else: tokens = token.split(",") for t in tokens: element = Node(t, current_parent, self.content_holder, getID(i)) current_parent.add_child(element) i += 1 output_html = '<!DOCTYPE html>\n<html lang="en">\n <head>\n <meta charset="utf-8" />\n <link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico" />\n <meta name="viewport" content="width=device-width, initial-scale=1" />\n <meta name="theme-color" content="#000000" />\n <!-- Bootstrap core CSS -->\n <link href="../compiled-bootstrap/css/bootstrap.css" rel="stylesheet">\n \n <!-- Custom styles for this template -->\n <link href="../effect.css" rel="stylesheet">\n <link href="../page.css" rel="stylesheet">\n\n <title>Generated Page</title>\n </head>\n <body>\n' output_html += self.root.render(self.dsl_mapping, rendering_function=rendering_function) output_html += '\n\t<script>\n\t\tvar x = document.getElementsByClassName("list-group-item");\n\t\tfor(var i = 0; i < x.length; i++) x[i].style.width = (parseInt(x[i].parentElement.offsetWidth) - 24) + "px";\n\t\tvar z = document.getElementsByClassName("card-header");\n\t\tfor(var i = 0; i < z.length; i++) z[i].style.width = (parseInt(z[i].parentElement.offsetWidth) - 24) + "px";\n\t</script>\n\n <script src="../jquery/jquery.min.js"></script>\n <script src="../compiled-bootstrap/js/bootstrap.bundle.min.js"></script>\n </body>\n</html>\n' with open(output_file_path, 'w') as output_file: output_file.write(output_html)
def parse_tree(cyk_matrix, current_symbol, i, j, errors, nonterminals): """Takes a Matrix, a symbol, a start location, an end location, the best error distance for the string, and a list of nonterminals and returns a parse tree for the individual characters in the string. This can be used to find I'. """ if i == j - 1: tups = cyk_matrix.get(i, j) if current_symbol in tups: tup = tups[current_symbol] if tup[1] == errors: return Node(i, j, tup[2]) raise LookupError('Could not find {} in cyk_matrix at {}'.format( current_symbol, (i, j))) A, B, q_1, q_2, dab, k = [None] * 6 try: for k in range(i + 1, j): for rhs, dab in nonterminals[current_symbol].items(): A, B = rhs.split() if A in cyk_matrix.get(i, k) and B in cyk_matrix.get(k, j): q_1 = cyk_matrix.get(i, k)[A][1] q_2 = cyk_matrix.get(k, j)[B][1] if dab.errors + q_1 + q_2 == errors: raise BreakIt raise LookupError(('Could not find match for right hand side of any ' 'production of {} in cyk_matrix at {}').format( current_symbol, (i, j))) except BreakIt: pass left = parse_tree(cyk_matrix, A, i, k, q_1, nonterminals) right = parse_tree(cyk_matrix, B, k, j, q_2, nonterminals) root = Node(i, j, dab) root.left = left root.right = right return root
def create_graph(self): """Creates a Huffman graph from self.heap""" while(len(self.heap.l) > 1): node1 = self.heap.pop() node2 = self.heap.pop() merged = Node(None, node1.freq + node2.freq) merged.left = node1 merged.right = node2 self.heap.push(merged)
def setUp(self): """ Setup method for initializing nodes Returns: """ self.first_node = Node(1) self.second_node = Node(2) self.first_node.next = self.second_node
def __init__(self, dsl_mapping_file_path): with open(dsl_mapping_file_path) as data_file: self.dsl_mapping = json.load(data_file) self.opening_tag = self.dsl_mapping["opening-tag"] self.closing_tag = self.dsl_mapping["closing-tag"] self.content_holder = self.opening_tag + self.closing_tag self.root = Node("body", None, self.content_holder)
def MakeNewElem(list): tempNode = Node("cvor", list[0].freq + list[1].freq) list[0].parent = tempNode list[1].parent = tempNode tempNode.left = list[0] tempNode.right = list[1] list.pop(0) list.pop(0) list.append(tempNode) list.sort()
def __init__(self, coordinates): """Constructof for IntersectionFinder.""" self.found = [] self.getDistance = GetGPSDistance.GetGPSDistance() # The coordinates are inverted here because search tree inverts path self.startPoint = Node.Node(-1, coordinates[2], coordinates[3]) self.endPoint = Node.Node(-2, coordinates[0], coordinates[1]) # [0] = Node ID, [1] = Distance from xPoint self.closestToStart = [sys.maxsize, 0] self.closestToEnd = [sys.maxsize, 0]
def createNode(): data = request.data data = json.loads(data) assert data["name"] node = Node() node.name = data["name"] getDomainRegistry().NodeRepository().save(node) return json.dumps(node.__dict__)
def test(): root = Node() root.right = Node() root.right.right = Node() root.right.right.right = Node() root.right.right.right.right = Node() root.right.left = Node() root.left = Node() root.left.right = Node() ibt = IsBalancedTree() print ibt.is_balanced(root)
def main(): selection = int(sys.argv[1]) # Reads in the board from the random_board.py output board = list(map(int, sys.stdin.read().split())) board = [[board[0], board[1], board[2]], [board[3], board[4], board[5]], [board[6], board[7], board[8]]] state = State(board) # Setting the x and y position for the blank tile for i in range(0, 3): for j in range(0, 3): if board[i][j] == 0: state.setx(i) state.sety(j) # Initialize the relevent data structures curr_node = Node(state, h(state, selection)) closed = Set() frontier = PriorityQueue() frontier.push(curr_node) V = 0 # Loops through and creates the search tree while objective(curr_node.getstate()) == False: closed.add(curr_node.getstate()) # Creates new states based on the valid_moves returned by the successor for valid_state in successor(curr_node.getstate()): V += 1 # Checking that the state we are eveluating has not already been expanded. Only adds to the queue if false if closed.isMember(valid_state) == False: frontier.push( Node(valid_state, h(valid_state, selection), curr_node)) curr_node = frontier.pop() N = closed.length() + frontier.length() d = curr_node.getd() print("V=%d" % (V)) print("N=%d" % (N)) print("d=%d" % (d)) print("b=%f" % (N**(1 / d))) print() # Create an empty list in order to retrieve the path from the goal node's parents stack = [] while curr_node.getid() != 0: stack.append(curr_node) curr_node = curr_node.getparent() print(curr_node.getstate()) # Prints out the solution path for node in reversed(stack): if node != None: print(node.getstate())
class TestNode(unittest.TestCase): def setUp(self): self.test_node_0 = Node(0, 0.1, 1, 1, 1, 1, 1, 1) self.test_node_1 = Node(1, 0.1, 1, 1, 1, 1, 1, 1) def test_add_neighbour(self): strength: int = 20 self.assertTrue(len(self.test_node_0.neighbours) == 0) self.assertTrue(len(self.test_node_1.neighbours) == 0) self.test_node_0.add_neighbour(self.test_node_1, strength) self.assertTrue(self.test_node_0.neighbours[1] == strength) self.assertTrue(1 in self.test_node_0.neighbours) self.assertTrue(len(self.test_node_1.neighbours) == 0)
def setUp(self): self.test_graph = Graph() self.test_node_0 = Node(0, 0.1, 1, 1, 1, 1, 1, 1) self.test_node_1 = Node(1, 0.2, 2, 2, 2, 2, 2, 2) self.test_node_2 = Node(2, 0.3, 1, 2, 3, 4, 5, 6) self.test_graph.add_vertex(self.test_node_0) self.test_graph.add_vertex(self.test_node_1) self.test_graph.add_vertex(self.test_node_2) self.test_graph.add_edge(self.test_node_0, self.test_node_1, 30) self.test_graph.add_edge(self.test_node_1, self.test_node_2, 50) self.test_sim = Simulation() self.test_sim.load_graph(self.test_graph)
def test(): root = Node(val=1) root.right = Node(val=2) root.right.right = Node(val=3) node1 = Node(val=4) root.right.right.right = node1 root.right.right.right.right = Node(val=5) node2 = Node(val=6) root.right.left = node2 root.left = Node(val=7) node3 = Node(8) root.left.right = node3 cm = CommonAncestor() print cm.find_anc(root, node1, node3).val
def test_push(self): """ Unit-test for stack.push method Returns: """ # Add new element by pushing into the stack, then check the value new_element = Node(4) self.stack.push(new_element) self.assertEqual(new_element.value, self.stack.peek()) # Add another element with push operation to make sure ;) new_element = Node(5) self.stack.push(new_element) self.assertEqual(new_element.value, self.stack.peek())
def read_graph_as_matrix(self, filename): file = open(filename, 'r') self.nodes, self.edges = list(), list() f = False tag = "A" lines = file.readlines() for i in range(len(lines)): if lines[i] != '\n': if f: # Создаем ребра weights = [int(x) for x in lines[i].split(' ')] for j in range(len(weights)): if weights[j] != 0: self.edges.append( Edge.Edge(self.nodes[i - 1], self.nodes[j], weights[j])) else: # Создаем нужное количество вершин amount = int(lines[0]) # print(amount) f = True for w in range(amount): self.nodes.append(Node.Node(tag)) tag = chr(ord(tag) + 1) self.normalize() pass
def main(): """ Main function for this file Returns: """ # Initialize a plotter plotter = Plotter() # Create BigO object to observe for each runtime complexity enqueue_op = BigO('Enqueue operation') dequeue_op = BigO('Dequeue operation') peek_op = BigO('Peek operation') # Add BigO objects to compare the plots plotter.add_objects(enqueue_op, dequeue_op, peek_op) for i in range(1000): queue = create_queue(i + 1) # Time enqueue function with a queue where the size == i node = Node(np.random.randint(0, 1000)) enqueue_op.time_function(enqueue_operation, node=node, queue=queue) # Time dequeue function with a dequeue where the size == 1 dequeue_op.time_function(dequeue_operation, queue=queue) # Time peek function with a queue of size i. peek_op.time_function(peek_operaiton, queue=queue) plt.ylim((0, 3e-5)) plotter.to_plot()
def heap_list(self, freq): """Takes a character-frequency dictionary, converts them into Nodes and sorts them into a heap""" for key in freq: node = Node(key, freq[key]) self.heap.append(node) self.heap = Heap(self.heap) self.heap.sort()
class Compiler: def __init__(self, dsl_mapping_file_path): with open(dsl_mapping_file_path) as data_file: self.dsl_mapping = json.load(data_file) self.opening_tag = self.dsl_mapping["opening-tag"] self.closing_tag = self.dsl_mapping["closing-tag"] self.content_holder = self.opening_tag + self.closing_tag self.root = Node("body", None, self.content_holder) def compile(self, dsl_file, rendering_function=None): # dsl_file = open(input_file_path) current_parent = self.root for token in dsl_file: token = token.replace(" ", "").replace("\n", "") if token.find(self.opening_tag) != -1: token = token.replace(self.opening_tag, "") element = Node(token, current_parent, self.content_holder) current_parent.add_child(element) current_parent = element elif token.find(self.closing_tag) != -1: current_parent = current_parent.parent else: tokens = token.split(",") for t in tokens: element = Node(t, current_parent, self.content_holder) current_parent.add_child(element) output_html = self.root.render(self.dsl_mapping, rendering_function=rendering_function) return output_html
def ReadNodes(fileName, delimiter_=','): """ read node input file and set up node objects. This function will automatically create an internal node ID for each node. Internal node IDs are consecutive non-negative integers starting from 0 as required by initializations of dist_apsp and pred_apsp. See CalculateAPSP(method='dij') for details. """ global _dict_nodes global _map_uid_id with open(fileName) as f: # skip the header next(f) csvf = csv.reader(f, delimiter=delimiter_) # internal node id used for calculation nodeID = 0 for r in csvf: # note that nodeUID here is STRING nodeUID = r[0].strip() _dict_nodes[nodeID] = Node(nodeID, nodeUID) if nodeUID not in _map_uid_id.keys(): _map_uid_id[nodeUID] = nodeID else: raise Exception('DUPLICATE NODE ID FOUND: ' + nodeUID) nodeID += 1
def loadDataSet(filename='data.xml'): tree = ET.parse(filename) root = tree.getroot() vehicles = [] for vehicle in root.iter('vehicle'): vehicle_dict = {} vehicle_dict['id'] = int(vehicle.get('id')) vehicle_dict['dep_node'] = int(vehicle.find('departure_node').text) vehicle_dict['ari_node'] = int(vehicle.find('arrival_node').text) vehicle_dict['capacity'] = float(vehicle.find('capacity').text) vehicle_dict['early'] = float(vehicle.find('early').text) vehicle_dict['late'] = float(vehicle.find('late').text) vehicle_dict['velocity'] = float(vehicle.find('velocity').text) vehicles.append(vehicle_dict) nodes = NodeList(vehicles) for node, request in zip(root.iter('node'), root.iter('request')): id_ = int(node.get('id')) type_ = int(node.get('type')) x = float(node.find('cx').text) y = float(node.find('cy').text) position = np.array([x, y]) early = float(node.find('early').text) late = float(node.find('late').text) service_time = float(node.find('s').text) demand = float(request.find('quantity').text) node_ = Node(id_, type_, position, early, late, service_time, demand) nodes.append(node_) return nodes
class Compiler: def __init__(self, dsl_mapping_file_path): with open(dsl_mapping_file_path) as data_file: self.dsl_mapping = json.load(data_file) self.opening_tag = self.dsl_mapping["opening-tag"] self.closing_tag = self.dsl_mapping["closing-tag"] self.content_holder = self.opening_tag + self.closing_tag self.root = Node("body", None, self.content_holder) def compile(self, input_file_path, output_file_path, rendering_function=None): dsl_file = open(input_file_path) current_parent = self.root for token in dsl_file: token = token.replace(" ", "").replace("\n", "") if token.find(self.opening_tag) != -1: token = token.replace(self.opening_tag, "") element = Node(token, current_parent, self.content_holder) current_parent.add_child(element) current_parent = element elif token.find(self.closing_tag) != -1: current_parent = current_parent.parent else: tokens = token.split(",") for t in tokens: element = Node(t, current_parent, self.content_holder) current_parent.add_child(element) output_html = self.root.render(self.dsl_mapping, rendering_function=rendering_function) with open(output_file_path, 'w') as output_file: output_file.write(output_html)
def list_sequences(node): """ List the input group recursively. Sequences and groups are listed before their children. Sequences are unwrapped, but only listed once. Bitfield are NOT listed. This filter can be used to generate structs in C/C++. """ sequences = [] _list_sequences_recursively(node, sequences) names = set() list = [] for seq in reversed(sequences): if seq.name not in names: names.add(seq.name) if hasattr(seq, 'nodes'): # NOTE: the sequence is unwrapped, lists all elements, we need only the defined ones for index in range(len(seq.nodes) / seq.number): item = seq.nodes[index] if item.is_sequence: list.append( Node(seq, {"number": item.number}, item.name)) # print "N", item.name, item.is_sequence, item.number else: list.append(item) # print "R", item.name, item.is_register list.append(seq) # print "S", seq.name return list
def parse_vrp(filepath): # read whole file s = open(filepath, "r").read() # get coordinates substring node_coord_section = extract_section(s, "NODE_COORD_SECTION", "DEMAND_SECTION").split('\n')[1:-1] # get demands substring demands_section = extract_section(s, "DEMAND_SECTION", "DEPOT_SECTION").split('\n')[1:-1] # extract client data from read strings number_of_clients = len(demands_section) nodes = [] for i in range(0, number_of_clients): # parse client data x, y = node_coord_section[i].strip().split(" ")[1:] demand = demands_section[i].strip().split(" ")[-1] # create node and add to nodes list nodes.append(Node(i, demand, x, y)) # extract capacity data from file capacity = int( extract_section(s, "CAPACITY :", "NODE_COORD_SECTION").strip()) return nodes, capacity
def main(): """ Main function for this file Returns: """ # Initialize a plotter plotter = Plotter() # Create BigO object to observe for each runtime complexity push_op = BigO('Push operation') pop_op = BigO('Pop operation') peek_op = BigO('Peek operation') # Add BigO objects to compare the plots plotter.add_objects(push_op, pop_op, peek_op) for i in range(1000): stack = create_stack(i + 1) # Time push function with a stack where the size == i node = Node(np.random.randint(0, 1000)) push_op.time_function(push_operation, node=node, stack=stack) # Time pop function with a stack where the size == 1 pop_op.time_function(pop_operation, stack=stack) # Time peek function with a stack of size i. peek_op.time_function(peek_operaiton, stack=stack) plt.ylim((1e-7 - 1e-5, 1e-7 + 1e-5)) plotter.to_plot()
def test_remove_vertex(self): n0, n1 = self.test_node_0, self.test_node_1 n2 = Node(2, 0.1, 1, 1, 1, 1, 1, 1) self.test_graph.add_vertex(n0) self.test_graph.add_vertex(n1) self.test_graph.add_vertex(n2) self.test_graph.add_edge(n0, n1, 5) self.test_graph.add_edge(n1, n2, 15) self.test_graph.add_edge(n2, n0, 25) self.test_graph.remove_vertex(0) # test_node_0 no longer in neighbours dicts self.assertFalse(0 in n1.neighbours) self.assertFalse(0 in n2.neighbours) # neighbours edges intact self.assertTrue(2 in n1.neighbours) self.assertTrue(1 in n2.neighbours) self.assertFalse(0 in self.test_graph.vertices) # try to remove something that is removed with self.assertRaises(AssertionError): self.test_graph.remove_vertex(0) self.test_graph.remove_vertex(1) self.assertFalse(1 in n2.neighbours)
def init_graph(): """ """ n = ['u', 'x', 'y', 'v', 'w', 'z'] e = ['uv', 'uw', 'vw', 'vx', 'ux', 'wx', 'xy', 'wy', 'wz', 'yz'] e_l_node = ['u', 'u', 'v', 'v', 'u', 'w', 'x', 'w', 'w', 'y'] e_r_node = ['v', 'w', 'w', 'x', 'x', 'x', 'y', 'y', 'z', 'z'] w = [2, 5, 3, 2, 1, 3, 1, 1, 5, 2] nb_node = len(n) nb_edge = len(e) E = {} for i in range(nb_edge): assert e[i] not in E.keys(), "{0} is in E".format(e[i]) E[e[i]] = Edge(e[i], e_l_node[i], e_r_node[i], w[i]) N = {} for i in range(nb_node): assert n[i] not in N.keys(), "{0} is in N".format(n[i]) N[n[i]] = Node(n[i]) for i in range(nb_edge): N[e_l_node[i]].insert_neigbors(e_r_node[i], w[i]) N[e_r_node[i]].insert_neigbors(e_l_node[i], w[i]) G = (N, E) return G
def setUp(self): """ Setup method to initialize a linked-list Returns: """ # Create test nodes self.head_node = Node(1) self.second_node = Node(2) self.third_node = Node(3) # Create test linked-list self.list = LinkedList(self.head_node) # Append nodes such that the list is: 1->2->3 self.list.append_right(self.second_node) self.list.append_right(self.third_node)
def setUp(self): """ Setup method for unit-testing. This method will be called for each test case in this file Returns: """ # Initialize a couple nodes to test the queue class self.first_node = Node(3) self.second_node = Node(2) self.third_node = Node(1) # Create a queue with elements created above self.queue = Queue() self.queue.enqueue(self.first_node) self.queue.enqueue(self.second_node) self.queue.enqueue(self.third_node)
def setUp(self): """ Setup method for unit-testing. This method will be called for each test case in this file Returns: """ # Create dummy nodes for testing the stack class self.first_node = Node(1) self.second_node = Node(2) self.third_node = Node(3) # Push all nodes into a stack self.stack = Stack() self.stack.push(self.first_node) self.stack.push(self.second_node) self.stack.push(self.third_node)
def __read_nodes(self, nodes): count = len(nodes.index) counter = 1 for (ind, row) in nodes.iterrows(): if counter % 10000 == 0: print(int(counter / count * 100), '%') counter += 1 self.nodes[row.id] = Node.Node(id_=row.id, x=row.lon, y=row.lat)
def shortest_path(source, target): """ Returns the shortest list of (movie_id, person_id) pairs that connect the source to the target. If no possible path, returns None. """ # create a node for the source start = Node(state=source, parent=None, action=None) # check if node is the solution and if not in put it into teh frontier if int(start.state) == int(target): return None else: frontier = QueueFrontier() frontier.add(start) # initialised an empty explored set() of nodes that have already been added explored = set() explored.add(int(start.state)) # loop until solution is found while True: # if frontier is empty then no solution found if frontier.empty(): return None # Choose a node from the frontier node = frontier.remove() # add neighbour nodes to frontier and check if they are the solution neighbors = neighbors_for_person(node.state) for movie, person in neighbors: if not person == target and int(person) not in explored: new_node = Node(state=person, parent=node, action=movie) frontier.add(new_node) elif person == target: new_node = Node(state=person, parent=node, action=movie) path = [] while new_node.parent is not None: path.append((new_node.action, new_node.state)) new_node = new_node.parent path.reverse() return path
def parse_tree(cyk_matrix, current_symbol, i, j, errors, nonterminals): """Takes a Matrix, a symbol, a start location, an end location, the best error distance for the string, and a list of nonterminals and returns a parse tree for the individual characters in the string. This can be used to find I'. """ if i == j - 1: tups = cyk_matrix.get(i, j) if current_symbol in tups: tup = tups[current_symbol] if tup[1] == errors: return Node(i, j, tup[2]) raise LookupError('Could not find {} in cyk_matrix at {}'.format( current_symbol, (i, j))) A, B, q_1, q_2, dab, k = [None] * 6 try: for k in range(i+1, j): for rhs, dab in nonterminals[current_symbol].items(): A, B = rhs.split() if A in cyk_matrix.get(i, k) and B in cyk_matrix.get(k, j): q_1 = cyk_matrix.get(i, k)[A][1] q_2 = cyk_matrix.get(k, j)[B][1] if dab.errors + q_1 + q_2 == errors: raise BreakIt raise LookupError(( 'Could not find match for right hand side of any ' 'production of {} in cyk_matrix at {}').format( current_symbol, (i, j))) except BreakIt: pass left = parse_tree(cyk_matrix, A, i, k, q_1, nonterminals) right = parse_tree(cyk_matrix, B, k, j, q_2, nonterminals) root = Node(i, j, dab) root.left = left root.right = right return root
def scan(locations, ignores): """ Walks through the file system and analyzes the files and folders""" startTime = datetime.datetime.now() node_lists = [] temp_filename_set = set() temp_foldername_set = set() dirs_analyzed = 0 files_analyzed = 0 # Search and mark the default folders found in the file system if sys.platform in ['Windows', 'win32']: default_locations = {os.path.join(HOME, folder) for folder in DEFAULT_FOLDERS["win"]} elif sys.platform in ['darwin']: default_locations = {os.path.join(HOME, folder) for folder in DEFAULT_FOLDERS["mac"]} apps_folder = [os.path.join(HOME, "Applications")] ignores.append(apps_folder) elif sys.platform in ['linux', 'linux2', 'linux3']: default_locations = {os.path.join(HOME, folder) for folder in DEFAULT_FOLDERS["linux"]} else: raise "Plattform not detected" for location in locations: norm_location = str(location) the_nodes = {} temp_nodes = {} node_id_counter = 0 file_id_counter = 0 def add_depths(node_id, depth): """ assigns depth to node, does same for children, their children... """ temp_node = the_nodes[node_id] temp_node.depth = depth for child in temp_node.children: add_depths(child, depth + 1) the_nodes[node_id] = temp_node def is_hidden_file(root, f): """ checks to see if file is hidden (OS-sensitive) """ if sys.platform in ['Windows', 'win32']: try: full_path = os.path.join(root, f) attrs = ctypes.windll.kernel32.GetFileAttributesW(full_path) assert attrs != -1 result = bool(attrs & 2) except (AttributeError, AssertionError): result = False return result else: # there are other ways to hide files in MacOS but they are incredibly obscure and presumably infrequently used. also very 'expensive' to check. if str(f).startswith('.'): return True else: return False def is_symlink_file(root, f): """ checks to see if a file is a shortcut or symlink (OS-sensitive) """ if sys.platform in ['Windows', 'win32']: if str(f)[-4:] == '.lnk': return True else: return False else: if os.path.islink(os.path.join(root, f)): return True else: return False # the actual walk process and the main observations made at each step for root, dirs, files in scandir(norm_location, topdown=True, onerror=None, followlinks=False): this_node = Node() root_head_tail = os.path.split(root) node_id_counter += 1 this_node.node_id = str(node_id_counter) this_node.name_length = len(root_head_tail[1]) if root in default_locations: this_node.default = True #TO DO: check to see if it is the desktop, if so, mark the folder (will require appro. folder property) this_node.letters = sum(char.isalpha() for char in root_head_tail[1]) this_node.numbers = sum(char.isdigit() for char in root_head_tail[1]) this_node.white_spaces = sum(char.isspace() for char in root_head_tail[1]) this_node.special_chars = sum(not char.isdigit() and not char.isalpha() and not char.isspace() for char in root_head_tail[1]) if root_head_tail[1] in temp_foldername_set: this_node.name_duplicate = True else: temp_foldername_set.add(root_head_tail[1]) try: root_stat_info = os.stat(root) this_node.m_time = datetime.datetime.fromtimestamp(root_stat_info.st_mtime).strftime("%Y-%m-%d %H:%M:%S") this_node.c_time = datetime.datetime.fromtimestamp(root_stat_info.st_ctime).strftime("%Y-%m-%d %H:%M:%S") if root_stat_info.st_nlink > 1: this_node.hard_link_duplicate = True except: this_node.m_time = -2 this_node.c_time = -2 original_dirs = len(dirs) # Removes folders to be ignored from walk for ignore in ignores: norm_ignore = str(ignore) dirs[:] = [d for d in dirs if not ((os.path.join(root, d) in norm_ignore) and (norm_ignore in os.path.join(root, d)))] ignored_children = (original_dirs - len(dirs)) dirs[:] = [d for d in dirs if os.access(os.path.join(root, d), os.W_OK)] inaccessible_children = (original_dirs - (len(dirs) + ignored_children)) dirs[:] = [d for d in dirs if not d[0] == '.'] this_node.hidden_children = (original_dirs - (len(dirs) + ignored_children + inaccessible_children)) dirs[:] = [d for d in dirs if not (os.path.islink(os.path.join(root, d)))] # store number of dirs that are actually symlinks this_node.symlinks = (original_dirs - (len(dirs) + ignored_children + inaccessible_children + this_node.hidden_children)) for d in dirs: dirs_analyzed += 1 # print("Scanning directory #{}: {}".format(dirs_analyzed, os.path.join(root, d))) this_node.path_children.append(os.path.join(root, d)) for f in files: files_analyzed += 1 # print("Scanning file #{}: {}".format(files_analyzed, os.path.join(root, f))) if is_symlink_file(root, f): # increment node.symlinks for each 'file' symlink found (counted in the same variable as folder symlinks) this_node.symlinks += 1 elif is_hidden_file(root, f): this_node.hidden_files += 1 else: this_file = File() file_id_counter += 1 this_file.file_id = file_id_counter this_file.full_name_length = len(str(f)) try: statinfo = os.stat(os.path.join(root, f)) except: statinfo = False if statinfo: if statinfo.st_nlink > 1: this_file.hard_link_duplicate = True this_file.a_time = datetime.datetime.fromtimestamp(statinfo.st_atime).strftime("%Y-%m-%d %H:%M:%S") this_file.m_time = datetime.datetime.fromtimestamp(statinfo.st_mtime).strftime("%Y-%m-%d %H:%M:%S") this_file.c_time = datetime.datetime.fromtimestamp(statinfo.st_ctime).strftime("%Y-%m-%d %H:%M:%S") this_file.file_size = statinfo.st_size if this_file.file_size == 0: try: this_file.file_size = os.path.getsize(os.path.join(root, f)) except: this_file.file_size = -2 else: this_file.a_time = -2 this_file.m_time = -2 this_file.c_time = -2 this_file.file_size = -2 if str(f) in temp_filename_set: this_file.name_duplicate = True else: temp_filename_set.add(str(f)) if '.' in f: split_name = f.rsplit('.', 1) this_file.extension = split_name[1] this_file.letters = sum(c.isalpha() for c in split_name[0]) this_file.numbers = sum(c.isdigit() for c in split_name[0]) this_file.white_spaces = sum(c.isspace() for c in split_name[0]) this_file.special_chars = sum(not c.isdigit() and not c.isalpha() and not c.isspace() for c in split_name[0]) else: this_file.letters = sum(c.isalpha() for c in f) this_file.numbers = sum(c.isdigit() for c in f) this_file.white_spaces = sum(c.isspace() for c in f) this_file.special_chars = sum(not c.isdigit() and not c.isalpha() and not c.isspace() for c in f) this_node.file_list.append(this_file) # this is done so that paths need not be permanently stored, but node relationships can be recorded for temp_id, temp_node in list(temp_nodes.items()): if (len(temp_node.path_children) < 1): the_nodes[temp_id] = temp_node del temp_nodes[temp_id] else: for path_child in temp_node.path_children: if ((root in path_child) and (path_child in root)): temp_node.children.append(str(this_node.node_id)) temp_node.path_children.remove(path_child) if len(this_node.path_children) > 0: temp_nodes[this_node.node_id] = this_node else: the_nodes[this_node.node_id] = this_node while len(temp_nodes) > 0: for temp_id, temp_node in list(temp_nodes.items()): while len(temp_node.path_children) > 0: for path_child in temp_node.path_children: temp_node.unknown_children += 1 temp_node.path_children.remove(path_child) the_nodes[temp_id] = temp_node del temp_nodes[temp_id] node_lists.append(the_nodes) add_depths("1", 0) # call the earlier defined function, starting from the top runtime = datetime.datetime.now() - startTime print("Walking runtime: {}".format(runtime)) return node_lists