def next_pos(curr_pos, curr_dir): if curr_dir == 0: return Point(curr_pos.x, curr_pos.y - 1) if curr_dir == 1: return Point(curr_pos.x + 1, curr_pos.y) if curr_dir == 2: return Point(curr_pos.x, curr_pos.y + 1) if curr_dir == 3: return Point(curr_pos.x - 1, curr_pos.y)
def get_result(self) -> int: topleft_x = min(x for x, y in self.d.keys()) topleft_y = min(y for x, y in self.d.keys()) offset = self.number_of_rows - 1 # number_of_rows == number_of_columns topleft = self.d[Point(topleft_x, topleft_y)] topright = self.d[Point(topleft_x + offset, topleft_y)] bottomleft = self.d[Point(topleft_x, topleft_y + offset)] bottomright = self.d[Point(topleft_x + offset, topleft_y + offset)] return topleft._id * topright._id * bottomleft._id * bottomright._id
def get_input_for_part2(self) -> str: """ Transform each tile: remove the borders. Leave no gap between the tiles. """ result = "" topleft_x = min(x for x, y in self.d.keys()) topleft_y = min(y for x, y in self.d.keys()) for row in range(topleft_y, topleft_y + self.number_of_rows): tiles_in_row = [] for col in range(topleft_x, topleft_x + self.number_of_columns): tile = self.d.get(Point(x=col, y=row), Tile.empty(TILE_WIDTH)) # matrix = tile.get_selected_variation() matrix = tile.get_tile_without_margins() tiles_in_row.append(matrix) # print(tile._id, end="; ") # for i in range(len(tiles_in_row[0])): line = "" for j in range(len(tiles_in_row)): curr_row = tiles_in_row[j][i] line += "".join(curr_row) # line += " " # # full_map.append(tuple(list(line))) result += line.rstrip() result += "\n" # # result += "\n" # return result.rstrip()
def find_empty_places(self) -> List[Point]: places: List[Point] = [] bag: Set[Point] = set() for key in self.d.keys(): x, y = key neighbors = self.get_four_neighbor_positions(x, y) for x, y in neighbors: if (x, y) not in self.d: if (x, y) not in bag: places.append(Point(x, y)) bag.add(Point(x, y)) # # # # return places
def __init__(self, width, height, players): self.width = width self.height = height self.players = players self.walls = set() self.resources = dict() self.resources_neighbours = set() self.weights = dict() self.house = Point()
def run2(self): df = pd.read_csv(self.fileName) df = df[pd.notnull(df['tags'])] df['post'] = df['post'].apply(cleanText) df = df.sort_values(by='tags') self.numberLabels = df['tags'].value_counts().size df['tags'] = pd.factorize(df.tags)[0] self.labels = df['tags'] vec = TfidfVectorizer(stop_words="english", max_features=100) vec.fit(df.post.values) features = vec.transform(df.post.values) objects = [] ind = 0 for coordinates in features.toarray(): point = Point() point.coordinates = coordinates.tolist() point.orgLabel = df.tags.values[ind] objects.append(point) ind += 1 self.objects = objects self.pointIndexes = len(self.objects) self.distanceMatrix = np.asmatrix( np.zeros((self.numOfMedoids, self.pointIndexes))) medoids, objects = self.execute() pca = PCA(n_components=2, random_state=random_state) reduced_features = pca.fit_transform(features.toarray()) reduced_cluster_centers = pca.transform(self.getCenters(medoids)) plt.scatter(reduced_features[:, 0], reduced_features[:, 1], c=self.getPredicted()) plt.scatter(reduced_cluster_centers[:, 0], reduced_cluster_centers[:, 1], marker='o', s=100, c='b') plt.show() ind = 0 for obj in reduced_features: self.objects[ind].x = obj[0] self.objects[ind].y = obj[1] ind += 1 print("ScikitLearn Homogenity:" + str(homogeneity_score(df.tags, self.getPredicted()))) print("ScikitLearn Completeness:" + str(completeness_score(df.tags, self.getPredicted()))) print("ScikitLearn Silhouette Score:" + str(silhouette_score(features, labels=self.getPredicted()))) return medoids, objects
def show_ids(self): topleft_x = min(x for x, y in self.d.keys()) topleft_y = min(y for x, y in self.d.keys()) for row in range(topleft_y, topleft_y + self.number_of_rows): for col in range(topleft_x, topleft_x + self.number_of_columns): tile = self.d[Point(x=col, y=row)] print(tile._id, end=" ") # print()
def doActionInPath(gameMap, currentPosition, direction, triggeringTileContent, action): # To cut down a tree, you must be on the tree instead of beside. nextPosition = Point(currentPosition.x + direction.x, currentPosition.y + direction.y) # If there is a wall at the given position, destroy it. if gameMap.getTileAt(nextPosition) == triggeringTileContent: return action(direction) else: return create_move_action(direction)
def deserialize(data): if "x" in data and "y" in data: return Point(data["x"], data["y"]) elif "Name" in data: return Player(data["Health"], data["MaxHealth"], data["CarriedResources"], data["CarryingCapacity"], data["CollectingSpeed"], data["TotalResources"], data["AttackPower"], data["Defence"], data["Position"], data["HouseLocation"], data["CarriedItems"], data["Score"], data["Name"], data["UpgradeLevels"]) elif "CustomSerializedMap" in data: data["GameMap"] = GameMap( data["CustomSerializedMap"], data["xMin"], data["yMin"], data["WallsAreBreakable"]) return data
def main() -> None: drawing = """ ##### #..E# #...# #...# #S#.# #.#.# ##### """.strip() maze = Maze(drawing) # pf = Pathfinder(maze) # pf.show() start = Point(x=1, y=4) end = Point(x=3, y=1) pf.set_start_point(start) pf.set_end_point(end) # pf.show_maze_with_distance_values() pf.start_bfs_discovery() pf.show_maze_with_distance_values() path = pf.find_shortest_path() print(path)
def __init__(self, eve_html, topology=None): self.uuid = uuid.uuid4() self.topology = topology self.eve_parsed_html = BeautifulSoup(eve_html, 'lxml') for br in self.eve_parsed_html.find_all("br"): br.replace_with("\n") css = self.eve_parsed_html.div['style'] self.eve_coordinates = Point( int(CSS_LEFT_RE.search(css).group('eve_x')), int(CSS_TOP_RE.search(css).group('eve_y'))) self.text = self.eve_parsed_html.text.strip()
def parse_node_dict(node_dict, gns_default_scene_size): """ Parses dictionary from xmltodict and returns a new dictionary with different variable names Args: node_dict: dictionary obtained from xmltodict and containing information about nodes Returns: dictionary containing class Node attribute names with their values """ params = dict() params['name'] = node_dict['@name'] params['eve_node_id'] = node_dict['@id'] params['node_type'] = node_dict['@type'] # iol, qemu params['template'] = node_dict['@template'] # vios, viosl2, iol params['image_path'] = node_dict['@image'] params['eve_icon'] = node_dict['@icon'] eve_x = node_dict['@left'] if '%' in eve_x: eve_x = gns_default_scene_size.width * int(eve_x.strip('%')) * 0.01 else: eve_x = int(eve_x) eve_y = node_dict['@top'] if '%' in eve_y: eve_y = gns_default_scene_size.height * int( eve_y.strip('%')) * 0.01 else: eve_y = int(eve_y) params['eve_coordinates'] = Point(eve_x, eve_y) if params['node_type'] == 'iol': params['ethernet_adapters_number'] = int(node_dict['@ethernet']) params['serial_adapters_number'] = int(node_dict['@serial']) elif params['node_type'] == 'qemu': params['console_type'] = node_dict['@console'] params['cpus'] = int(node_dict['@cpu']) params['ram'] = int(node_dict['@ram']) params['adapters'] = int(node_dict['@ethernet']) else: raise NotImplementedError( f'Parser for the node type {params["node_type"]} is not implemented' ) return params
def start(self) -> None: self.insert_first_puzzle() # cnt = 0 while not self.finished(): # cnt += 1 # if cnt == 2: # self.debug() # exit(1) empty_places: List[Point] = self.find_empty_places() for empty_place in empty_places: x, y = empty_place neighbor_positions = self.get_four_neighbor_positions(x, y) tile = self.find_matching_tile(x, y, neighbor_positions) if tile: self.d[Point(x, y)] = tile # self.show_dictionary() break
def show_content(self) -> None: topleft_x = min(x for x, y in self.d.keys()) topleft_y = min(y for x, y in self.d.keys()) for row in range(topleft_y, topleft_y + self.number_of_rows): tiles_in_row = [] for col in range(topleft_x, topleft_x + self.number_of_columns): tile = self.d.get(Point(x=col, y=row), Tile.empty(TILE_WIDTH)) matrix = tile.get_selected_variation() # matrix = tile.get_tile_without_margins() tiles_in_row.append(matrix) # print(tile._id, end="; ") # for i in range(len(tiles_in_row[0])): line = "" for j in range(len(tiles_in_row)): curr_row = tiles_in_row[j][i] line += "".join(curr_row) line += " " # # full_map.append(tuple(list(line))) print(line) # print()
def __init__(self): self.normal = Point(0, 0, -1.0) self.center = Point(0, 0, -0.06)
def __init__(self): self.center = Point(0.0, -0.1, -0.25) self.radius = 0.1
def __init__(self): self.center = Point(0, 0.1, -0.1) self.radius = 0.05
def insert_first_puzzle(self) -> None: tile = self.tiles.list_of_tiles[0] tile.index_of_selected_variation = 0 self.d[Point(0, 0)] = tile
def next_pos(curr_pos, curr_dir): if curr_dir == 0: return Point(curr_pos.x, curr_pos.y - 1) if curr_dir == 1: return Point(curr_pos.x + 1, curr_pos.y) if curr_dir == 2: return Point(curr_pos.x, curr_pos.y + 1) if curr_dir == 3: return Point(curr_pos.x - 1, curr_pos.y) grid = defaultdict(lambda: 0) c = IntCode(program) curr_pos = Point(0, 0) curr_dir = 0 while not c.halt: output_paint, output_dir = c.run([grid[curr_pos]]) grid[curr_pos] = output_paint curr_dir = next_dir(curr_dir, output_dir) curr_pos = next_pos(curr_pos, curr_dir) print("part 1") print(len(grid)) print("part 2") grid = defaultdict(lambda: 0) c = IntCode(program)
class Node(object): """ TODO @DynamicAttrs """ L2_IOL_LABEL_COORDINATES = Point(-4, 46) L3_IOL_LABEL_COORDINATES = Point(15, 46) DEFAULT_LABEL_COORDINATES = Point(5, -25) SWITCH_SYMBOL_SIZE = Size(51, 48) ROUTER_SYMBOL_SIZE = Size(66, 45) def __init__(self, interfaces_dict=None, **kwargs): self.uuid = uuid.uuid4() for attr_name, attr_value in kwargs.items(): setattr(self, attr_name, attr_value) # self.eve_node_id = eve_node_id # self.name = name # self.node_type = node_type # self.image_path = image_path # self.eve_icon = eve_icon # self.eve_coordinates = eve_coordinates # # self.serial_adapters_number = serial_adapters_number # self.ethernet_adapters_number = ethernet_adapters_number self.config = None self.interfaces = [] self.id_to_interface = {} # self.topology = topology self.topology.id_to_node[self.eve_node_id] = self if interfaces_dict is not None: self.parse_interfaces(interfaces_dict) @classmethod def from_dict(cls, node_dict, topology=None): """ TODO Creates a Node object if it does exist based on the node_dict Args: node_dict: dictionary, obtained from xmltodict representing the node id_to_network: dictionary, containing mapping from Network id to Network object id_to_node: dictionary, containing mapping from Node id to Node object Returns: instance of the class Node Examples: node_dict = {'@name': 'R1', '@eve_node_id': '123'} node = Node.from_dict(node_dict, {}, {}) """ params = cls.parse_node_dict(node_dict, topology.GNS_DEFAULT_SCENE_SIZE) node = topology.id_to_node.get(params['eve_node_id']) params['topology'] = topology interfaces_dict = node_dict.get('interface', []) if node is None: params['interfaces_dict'] = interfaces_dict # if the node does not yet exist, create a new one using class constructor return cls(**params) else: # if node already exists go through each attribute and set it for the existing object for attr_name, attr_value in params.items(): setattr(node, attr_name, attr_value) node.parse_interfaces(interfaces_dict) return node @staticmethod def parse_node_dict(node_dict, gns_default_scene_size): """ Parses dictionary from xmltodict and returns a new dictionary with different variable names Args: node_dict: dictionary obtained from xmltodict and containing information about nodes Returns: dictionary containing class Node attribute names with their values """ params = dict() params['name'] = node_dict['@name'] params['eve_node_id'] = node_dict['@id'] params['node_type'] = node_dict['@type'] # iol, qemu params['template'] = node_dict['@template'] # vios, viosl2, iol params['image_path'] = node_dict['@image'] params['eve_icon'] = node_dict['@icon'] eve_x = node_dict['@left'] if '%' in eve_x: eve_x = gns_default_scene_size.width * int(eve_x.strip('%')) * 0.01 else: eve_x = int(eve_x) eve_y = node_dict['@top'] if '%' in eve_y: eve_y = gns_default_scene_size.height * int( eve_y.strip('%')) * 0.01 else: eve_y = int(eve_y) params['eve_coordinates'] = Point(eve_x, eve_y) if params['node_type'] == 'iol': params['ethernet_adapters_number'] = int(node_dict['@ethernet']) params['serial_adapters_number'] = int(node_dict['@serial']) elif params['node_type'] == 'qemu': params['console_type'] = node_dict['@console'] params['cpus'] = int(node_dict['@cpu']) params['ram'] = int(node_dict['@ram']) params['adapters'] = int(node_dict['@ethernet']) else: raise NotImplementedError( f'Parser for the node type {params["node_type"]} is not implemented' ) return params @property def role(self): if 'router' in self.eve_icon.lower(): return 'router' elif 'switch' in self.eve_icon.lower(): return 'switch' else: return None def __repr__(self): return f'Node(eve_node_id={self.eve_node_id}, name={self.name})' def parse_interfaces(self, interfaces_dict): """ TODO Goes through each interface in the dictionary and creates Interface objects for them Args: interfaces_dict: dictionary retrieved from xmltodict containing information about interfaces id_to_network: dictionary containing Network id to Network object mapping id_to_node: dictionary containing Node id to Node object mapping Modifies: self.interfaces - adds a new Interface to the list id_to_node - adds an id to Node object mapping to the dictionary May create a remote Node object and Interface if needed """ def parse_interface_dict(int_dict): link_type = int_dict['@type'] eve_interface_id = int(int_dict['@id']) eve_interface_name = int_dict['@name'] try: interface = self.get_interface(eve_interface_id) interface.eve_name = eve_interface_name except exceptions.MissingInterface: if link_type == 'ethernet': eve_network_id = int_dict['@network_id'] eve_network = self.topology.id_to_network.get( eve_network_id) self.create_interface( eve_interface_id=eve_interface_id, eve_interface_name=eve_interface_name, eve_network=eve_network) elif link_type == 'serial': eve_remote_node_id = int_dict['@remote_id'] eve_remote_interface_id = int(int_dict['@remote_if']) remote_node = self.topology.id_to_node.get( eve_remote_node_id) if remote_node is None: # remote node does not exist yet remote_node = Node(eve_node_id=eve_remote_node_id, topology=self.topology) try: remote_interface = remote_node.get_interface( eve_remote_interface_id) except exceptions.MissingInterface: remote_interface = remote_node.create_interface( eve_interface_id=eve_remote_interface_id, remote_node=self) # I do not update interface details later! local_interface = self.create_interface( eve_interface_id=eve_interface_id, eve_interface_name=eve_interface_name, remote_node=remote_node) remote_interface.remote_node = self # link interfaces between each other local_interface.remote_interface = remote_interface remote_interface.remote_interface = local_interface # create Link object if the link is point to point link = Link(interfaces=(local_interface, remote_interface)) local_interface.link = link remote_interface.link = link self.topology.links.append(link) for interface_dict in interfaces_dict: parse_interface_dict(interface_dict) def get_interface(self, interface_id): """ Gets an Interface object based on interface_id Args: interface_id: string, id of the interface in source xml file Returns: Interface object having this interface_id if exists Raises: errors.MissingInterface if interface was not found """ try: return self.id_to_interface[interface_id] except KeyError: raise exceptions.MissingInterface( f'Interface with id {interface_id} does not exist on node with id {self.eve_node_id}' ) def create_interface(self, eve_interface_id, eve_interface_name=None, eve_network=None, remote_node=None, remote_interface=None): """ Creates an Interfaces object and stored it in self.interfaces list Args: eve_interface_id: string, interface id in source XML file eve_interface_name: string, interface name in source XML file eve_network: Network object to which an interface is connected remote_node: Node object, a Node to which an interface is connected if the link is serial remote_interface: Interface object, which belongs to a Node to which an interface is connected if the link is serial Returns: Interface object Modifies: self.interfaces - adds an Interface object to this list self.id_to_interface - adds id to Interface object mapping for quick access """ interface = Interface(eve_id=eve_interface_id, eve_name=eve_interface_name, eve_network=eve_network, node=self, remote_node=remote_node, remote_interface=remote_interface) self.id_to_interface[eve_interface_id] = interface self.interfaces.append(interface) return interface @property def gns_coordinates(self): return self.topology.get_gns_coordinates(self.eve_coordinates) @property def gns_image(self): if self.node_type == 'iol' and self.role == 'switch' and self.topology.args.l2_iol_image: return self.topology.args.l2_iol_image elif self.node_type == 'iol' and self.role == 'router' and self.topology.args.l3_iol_image: return self.topology.args.l3_iol_image else: return self.image_path @property def gns_label_coordinates(self): if self.node_type == 'iol' and self.role == 'switch': return self.L2_IOL_LABEL_COORDINATES elif self.node_type == 'iol' and self.role == 'router': return self.L3_IOL_LABEL_COORDINATES else: return self.DEFAULT_LABEL_COORDINATES @property def gns_icon(self): if self.role == 'switch': return ':/symbols/multilayer_switch.svg' elif self.role == 'router': return ':/symbols/router.svg' @property def gns_icon_size(self): if self.role == 'switch': return self.SWITCH_SYMBOL_SIZE elif self.role == 'router': return self.ROUTER_SYMBOL_SIZE @property def gns_icon_center_coordinates(self): return self.gns_coordinates + self.gns_icon_size / 2 def write_config_to_dir(self, dst_dir): """ Creates a config file for the node in the specified directory on disk Args: dst_dir: string, destination directory where the file should be written Returns: None """ if self.config: filename = f'{self.name}_startup-config.cfg' path = os.path.join(dst_dir, filename) with open(path, 'wb') as f: f.write(self.config) def build_gns_topology_json(self): if self.node_type == 'iol': node_json = copy.deepcopy(json_templates.IOL_JSON_TEMPLATE) node_json['properties'][ 'ethernet_adapters'] = self.ethernet_adapters_number node_json['properties'][ 'serial_adapters'] = self.serial_adapters_number node_json['properties']['path'] = self.gns_image elif self.node_type == 'qemu': node_json = copy.deepcopy(json_templates.QEMU_JSON_TEMPLATE) node_json['properties']['adapters'] = self.adapters node_json['properties']['cpus'] = self.cpus node_json['properties']['ram'] = self.ram node_json['properties']['hda_disk_image'] = self.gns_image if self.template == 'vios': node_json['port_name_format'] = 'Gi0/{0}' node_json['properties'][ 'hdb_disk_image'] = 'IOSv_startup_config.img' node_json['properties']['hdb_disk_interface'] = 'virtio' elif self.template == 'viosl2': node_json['port_name_format'] = 'Gi{1}/{0}' node_json['properties']['port_segment_size'] = 4 else: node_json['port_name_format'] = 'Gi0/{0}' else: raise NotImplementedError( "There is no template for the node type {self.node_type}") node_json['console'] = self.topology.console_start_port + int( self.eve_node_id) node_json['label']['text'] = self.name node_json['name'] = self.name node_json['node_id'] = str(self.uuid) node_json['symbol'] = self.gns_icon gns_coordinates = self.gns_coordinates node_json['x'] = gns_coordinates.x node_json['y'] = gns_coordinates.y node_json['width'] = self.gns_icon_size.x node_json['height'] = self.gns_icon_size.y gns_label_coordinates = self.gns_label_coordinates node_json['label']['x'] = gns_label_coordinates.x node_json['label']['y'] = gns_label_coordinates.y return node_json