def __init__(self, code: typing.List[str], filename: str, primary_function: str): self.code = code self._generated_code = [] self._node_num = -1 self._reset = False self.filename = filename self.shader_name = self.filename.split("/")[-1].split(".")[0] self.functions = [] self.imports = IndexedSet() self.connected_code = IndexedSet() self.parse_time = 0 self._primary_func_name = primary_function self.primary_function: GLSLFunction = None self._uniforms = [] self._arguments_to_add_to_primary = [] # Track line numbers of important parts of code self._functions_start_line = -1 self._primary_func_start_line = -1 self._parse() self._set_primary_function() self._add_args_to_primary()
def test_indexed_set_mutate(): thou = IndexedSet(range(1000)) assert (thou.pop(), thou.pop()) == (999, 998) assert (thou.pop(499), thou.pop(499)) == (499, 500) ref = [495, 496, 497, 498, 501, 502, 503, 504, 505, 506] assert [thou[i] for i in range(495, 505)] == ref assert len(thou) == 996 while len(thou) > 600: dead_idx_len = len(thou.dead_indices) dead_idx_count = thou._dead_index_count thou.pop(0) new_dead_idx_len = len(thou.dead_indices) if new_dead_idx_len < dead_idx_len: assert dead_idx_count > 0 # 124, 109, 95 assert len(thou) == 600 assert thou._dead_index_count == 67 assert not any([thou[i] is _MISSING for i in range(len(thou))]) thou &= IndexedSet(range(500, 503)) assert thou == IndexedSet([501, 502]) return
def __init__(self, parent_node: 'Node', socket_type: SocketType, dtype: DataType = None, label: str = "", container=None): super().__init__(container) assert isinstance(socket_type, SocketType), "socket_type must be of enum type SocketType!" self._parent_g_node = parent_node self._type = socket_type self._dtype = dtype self._label = label self._id = uuid.uuid4() self._index = -1 self._value = None self._saved_value = None self._connected = False self._connected_sockets = IndexedSet() self._connected_edges = IndexedSet()
def find_instruction_order(instructions: OrderedMultiDict): starting_instruction = set(instructions.keys(multi=True)).difference( set(instructions.values(multi=True))) worker_manager = WorkerManager(offset=0) instruction_order = IndexedSet() current_instructions = list() for index, value in enumerate(sorted(starting_instruction)): current_instructions.append(value) worker_manager.add(value) current_instructions = sorted(current_instructions) while current_instructions: index = -1 for i, current_instruction in enumerate(current_instructions): if not { key for key, value in instructions.items(multi=True) if value == current_instruction }.difference(instruction_order): instruction_order.add(current_instruction) worker_manager.remove(current_instruction) for n, value in enumerate( instructions.getlist(current_instruction)): if value not in current_instructions: current_instructions.append(value) index = i break if index != -1: current_instructions.pop(index) current_instructions = sorted(current_instructions) for instruction in current_instructions: worker_manager.add(instruction) print("".join(instruction_order)) print(worker_manager.start_time)
def __init__(self, expectations=None): super(ArsdkMultipleExpectation, self).__init__() if expectations is None: self.expectations = [] else: self.expectations = expectations self.matched_expectations = IndexedSet()
def solve_binary_pick_k(self, show_spent_time: bool = True) -> list: """ 借助Binary Search的思想,每次從post_list中N篇文章中找出相對排序最前面1個,重複k次 時間複雜度 O(k log N) 空間複雜度 O(N) Returns: [list]: Top-K articles """ if show_spent_time: start = time.time() top_k_posts_list = [] n_picks = 0 post_set = IndexedSet(self.post_list) # 一個重複k次的迴圈,時間複雜度 O(k) while n_picks < self.top_k: # binary pick,採Divide and Conquer,時間複雜度 O(log N) curr_best_post = binary_pick( self.ranker, post_set, left=0, right=len(post_set) - 1) top_k_posts_list.append(curr_best_post) # 加入元素到list 時間複雜度 O(1) # 從IndexableSet移除元素,時間複雜度O(1) (HashTable) post_set.remove(curr_best_post) n_picks += 1 if show_spent_time: spent = (time.time() - start) * 1000 print(self) print(f'spent time {spent:.2f} ms') return top_k_posts_list
def search(): context = dict() try: if request.args: key_word = request.args["key"] df = pd.read_csv(Name_File_Path) search_result = [] for idx in range(len(key_word) - 2): search_q = key_word[:len(key_word) - idx] r_list, used_word = get_search_result(df, "Name", search_q.lower()) search_result.extend(r_list) index = df["Name"][used_word == True].index df = df.drop(index=index, axis=0) result = list(IndexedSet(search_result)) if not result: context["message"] = "No Result Found!" else: context["search_result"] = result return jsonify(context) else: return render_template("index.html", context=context) except Exception as e: return render_template("index.html", context={ "error_message": str(e), "message": "Internal server error" })
def __init__(self, expectations=None): super().__init__() if expectations is None: self.expectations = [] else: self.expectations = expectations self.matched_expectations = IndexedSet()
def __init__(self, parent_node: 'GShaderNode', socket: NodeSocket): super().__init__(parent=parent_node) self._socket = socket self._socket.set_container(self) self._parent_g_node = parent_node self._connected_g_edges = IndexedSet() # Define socket properties self._circle_connected_brush = QColor( 255, 130, 0, 255) if self._socket.type() == NodeSocket.INPUT else QColor( 130, 255, 0, 255) self._circle_disconnected_brush = QColor( 102, 50, 0, 255) if self._socket.type() == NodeSocket.INPUT else QColor( 50, 102, 0, 255) self._circle_hover_brush = QColor( 170, 130, 0, 255) if self._socket.type() == NodeSocket.INPUT else QColor( 130, 170, 0, 255) self._border_connected_brush = QPen(QColor(255, 255, 255, 255)) self._border_disconnected_brush = QPen(Qt.black) self._circle_brush = self._circle_disconnected_brush self._border_brush = self._border_disconnected_brush self._bbox = QRectF(0, 0, 10, 10) self._moving_edge = False self._current_edge = None self._layout = QGraphicsLinearLayout(Qt.Horizontal) self._init_socket()
def __init__(self, logfile, buffs, regex): print(regex) self.logfile = logfile self.bufflist = buffs self.rx = re.compile(regex) self.windowName = "EverQuest" self.buffqueue = IndexedSet()
def __init__(self, name="Sub-Topology", parent=None): if name is not None: self._name = str(name) if parent is None: self._parent = parent else: self._parent = _validate_parent(parent) self._sites = IndexedSet()
def __init__(self, cards: Collection[Card]): self.cards: IndexedSet = IndexedSet(cards) le = len(cards) if le < 5: raise ValueError('At least five cards are needed for a ' 'straight. Only {} were given'.format(le)) if dog in cards: raise ValueError('Dog not usable in Patterns') self.cardinality = len(cards) # Check consistency of given cards! sorted_cards = sorted(cards, key=Card.rank) sorted_cards_iter = iter(sorted_cards) first_card = next(sorted_cards_iter) self.rank = first_card.rank phx_avail = has_phoenix(sorted_cards) redundant_ranks = [] self.phx_rank = None last_rank = self.rank buf = [] for current_card in sorted_cards_iter: if current_card.special == Special.phoenix: continue diff = current_card.rank - last_rank if diff == 0: redundant_ranks.append(current_card.rank) elif diff == 1: last_rank = current_card.rank elif diff == 2 and phx_avail: phx_avail = False last_rank = current_card.rank else: raise ValueError("Inconsistent Straight") # if phx was not used to build the straight # it can make the straight longer if phx_avail: # append phx to the end (if not already ace) if last_rank < 14: last_rank += 1 self.phx_rank = last_rank elif self.rank > 2: self.rank -= 1 self.phx_rank = self.rank self.redundant_cards = []; self.essential_cards = [] for c in cards: if c.rank in redundant_ranks: self.redundant_cards.append(c) else: self.essential_cards.append(c) self.highest = last_rank self.cardinality = self.highest - self.rank + 1
def get_output_target_nodes(self) -> IndexedSet: """Returns a set of all nodes connected to this nodes output socket.""" out = IndexedSet() for socket in self.get_output_sockets(): if socket.is_connected(): out.update(socket.get_connected_nodes()) return out
def test_iset_index_method(): original_list = list(range(8, 20)) + list(range(8)) indexed_list = IndexedSet() for i in original_list: indexed_list.add(i) for i in original_list: index = indexed_list.index(i) # if we're removing them in order, the target value should always be at index 0 assert index == 0 indexed_list.pop(index) indexed_list = IndexedSet(range(10)) for i in reversed(range(10)): if i % 2: continue index = indexed_list.index(i) assert i == indexed_list.pop(index) indexed_list = IndexedSet(range(32)) for i in list(indexed_list): if i % 3: index = indexed_list.index(i) assert i == indexed_list.pop(index) indexed_list = IndexedSet(range(10)) for i in range(10): if i < 3: continue index = indexed_list.index(i) assert i == indexed_list.pop(index) indexed_list = IndexedSet(range(32)) for i in list(indexed_list): if i % 3: index = indexed_list.index(i) assert i == indexed_list.pop(index)
def get_ancestor_nodes(self, add_self: bool = False) -> IndexedSet: """ Returns a list of all connected ancestors of this node. :param add_self: if True, adds this node to the set of returned nodes. :return: a Set of nodes that are ancestors of this node. """ nodes = self._node.get_ancestor_nodes(add_self=add_self) out = IndexedSet() for n in nodes: out.add(n.get_container()) return out
async def dist_cards(self, cards: List[Card], player_number: int): self.player_number = player_number # using intersection & slicing self.hand = IndexedSet(cards) self.stash = list() self.extplayer.init_player(player_number) bigTichu = await self.extplayer.dist_first(self.hand[0:8]) if bigTichu.event == TEventType.BigTichu: await self.server.put(bigTichu) smallTichu = await self.extplayer.dist_second(self.hand[9:14]) if smallTichu.event == TEventType.SmallTichu: await self.server.put(smallTichu)
def __init__(self, name="Topology", box=None): if name is not None: self._name = name else: self._name = "Topology" self._box = box self._sites = IndexedSet() self._typed = False self._connections = IndexedSet() self._bonds = IndexedSet() self._angles = IndexedSet() self._dihedrals = IndexedSet() self._subtops = IndexedSet() self._atom_types = {} self._connection_types = {} self._bond_types = {} self._angle_types = {} self._dihedral_types = {} self._combining_rule = 'lorentz' self._set_refs = { ATOM_TYPE_DICT: self._atom_types, BOND_TYPE_DICT: self._bond_types, ANGLE_TYPE_DICT: self._angle_types, DIHEDRAL_TYPE_DICT: self._dihedral_types, }
def convert_hbih_to_gmusic(self, url): hbih_list = HBIHPlaylist(url) title = hbih_list.title store_ids = [] for item in hbih_list.items: album_store_ids = self.get_best_album_match(item[0], item[1]) print("Adding store ids: {0}".format(album_store_ids)) store_ids.extend(album_store_ids) store_id_set = IndexedSet(store_ids) no_dupes_store_ids = list(store_id_set) new_plist = self.create_playlist(title, no_dupes_store_ids[0:1000]) return self.share_playlist(new_plist)
def _consume_next_xlref(self, xlref, lasso): """ :param str xlref: an xlref that may not contain hash(`#`); in that case, it is taken as *file-part* or as *fragment-part* depending on the existence of prev lasso's `url_file`. :param Lasso lasso: reuses `url_file` & `sheet` if missing from xlref """ xlref = _guess_xlref_without_hash(xlref, bias_on_fragment=bool( lasso.url_file)) lasso = xleash.lasso(xlref, sheets_factory=self._sheets_factory, url_file=lasso.url_file, sheet=lasso.sheet, return_lasso=True) values = lasso.values if values: # Skip blank sheets. # TODO: Convert column monkeybiz into pure-pandas using xleash. str_row_indices = [ i for i, r in enumerate(values) if any( isinstance(v, str) for v in r) ] req_labels = IndexedSet(self.required_labels) for k in str_row_indices: if set(values[k]) >= req_labels: break else: raise CmdException( "Columns %r not found in table of sheet(%r) in book(%r)!" % (self.required_labels, lasso.sheet._sheet.name, lasso.sheet.book_fname)) ix = values[k] i = max(str_row_indices, default=0) + 1 h = pd.DataFrame(values[:i], columns=ix) self.headers.append((sheet_name(lasso), k, h)) values = pd.DataFrame(values[i:], columns=ix) values.dropna(how='all', inplace=True) values.dropna(axis=1, how='any', inplace=True) if values.empty: log.warning("Empty table of sheet(%r) in book (%r)!" % (lasso.sheet._sheet.name, lasso.sheet.book_fname)) else: self.tables.append(values) return lasso
def paramaterize_cases( cases: List[ParamCase], default_values: Optional[ParamaterizationVars] = None, fill_none: bool = True, fill_default: bool = False, ) -> ParamaterizationArgs: """Create paramaterization from a set of named cases.""" _default = default_values or {} # Build the list of paramaterized values argnames = IndexedSet() if fill_default: argnames |= IndexedSet(_default.keys()) # Build list case ids, values, and add any argnames that weren't in default ids = [] case_values = [] for case in cases: ids.append(case.id) argnames |= IndexedSet(case.variables.keys()) case_values.append(case.variables) # Convert argnames to a list once we have identified all posibilities argnames = list(argnames) # Build list of tuples of values argvalues = [ tuple([ _get_from_lists(var, [values, _default], raise_error=not fill_none) for var in argnames ]) for values in case_values ] return ParamaterizationArgs( argnames=argnames, argvalues=argvalues, ids=ids, )
def store_selection(self): """Remember to call it on "ok", to persist history of selected paths.""" print("Storing selection...") if self.stkey_last_path: sect, key = self.stkey_last_path.split('.') store_put(sect, key, self.path) if self.stkey_paths_hist: sect, key = self.stkey_paths_hist.split('.') try: paths_hist = IndexedSet(store_get(sect, key, [])) paths_hist.add(self.path) paths_hist = list( reversed(paths_hist)) # earlier elements at list-head except: paths_hist = [self.path] store_put(sect, key, paths_hist)
def build_structure(self, decision_table: DecisionTable) -> [str]: """ Builds meta representation structure based on the dictionary representation of the structure :param decision_table: :return: """ structure_dict = self.build_structure_dict(decision_table) predicate_names = structure_dict.keys() structure: [str] = [] for predicate in predicate_names: value_list = structure_dict[predicate] # remove doubles unique_value_list = list(IndexedSet(value_list)) values_string = '; '.join(unique_value_list) structure.append(predicate + " = {" + values_string + "}") return structure
def get_ancestor_nodes(self, add_self: bool = False) -> IndexedSet: """ Returns a list of all connected ancestors of this node. :param add_self: if True, adds this node to the set of returned nodes. :return: a Set of nodes that are ancestors of this node. """ out = IndexedSet() if add_self: out.add(self) for socket in self.get_input_sockets(): if socket.is_connected(): for node in [n for n in socket.get_connected_nodes()]: out.update(node.get_ancestor_nodes(add_self=True)) return out
def autocomplete(self, request): key = request.query_params.get('key', None) trie = OurRepo.getInstance().our_trie_root comp = trie.all_suggestions(key) if comp == 1: response = trie.words print(' 1: The type of response is: ' + str(type(response))) grand_response = [] for element in response: grand_response.append(element.get("word")) print(grand_response) count = response.__len__() response_ = None if response.__len__() < MAX_COUNT: print('Reached here') response_ = trie.search_with_typo(2, key) response_ = list(dict(response_).keys()) if response_ is not None: for key in response_: if count == MAX_COUNT: break grand_response.append(key) count += 1 else: print("2:: ") length = 1 count = 0 grand_response = [] while grand_response.__len__() < MAX_COUNT: response = None while response is None: response = trie.search_with_typo(length, key) length += 1 response = list(dict(response).keys()) for element in response: if count == MAX_COUNT: break grand_response.append(element) count += 1 for result in response: print(result) response__ = list(IndexedSet(grand_response)) return Response(response__, status=status.HTTP_200_OK)
def __init__(self, name="Topology", box=None): self.name = name self._box = box self._sites = IndexedSet() self._typed = False self._connections = IndexedSet() self._bonds = IndexedSet() self._angles = IndexedSet() self._dihedrals = IndexedSet() self._impropers = IndexedSet() self._subtops = IndexedSet() self._atom_types = {} self._atom_types_idx = {} self._connection_types = {} self._bond_types = {} self._bond_types_idx = {} self._angle_types = {} self._angle_types_idx = {} self._dihedral_types = {} self._dihedral_types_idx = {} self._improper_types = {} self._improper_types_idx = {} self._combining_rule = 'lorentz' self._scaling_factors = { "vdw_12": 0.0, "vdw_13": 0.0, "vdw_14": 0.5, "coul_12": 0.0, "coul_13": 0.0, "coul_14": 0.5, } self._set_refs = { ATOM_TYPE_DICT: self._atom_types, BOND_TYPE_DICT: self._bond_types, ANGLE_TYPE_DICT: self._angle_types, DIHEDRAL_TYPE_DICT: self._dihedral_types, IMPROPER_TYPE_DICT: self._improper_types, } self._index_refs = { ATOM_TYPE_DICT: self._atom_types_idx, BOND_TYPE_DICT: self._bond_types_idx, ANGLE_TYPE_DICT: self._angle_types_idx, DIHEDRAL_TYPE_DICT: self._dihedral_types_idx, IMPROPER_TYPE_DICT: self._improper_types_idx } self._unique_connections = {}
def big_popper(): # more of a benchmark than a test from os import urandom import time big_set = IndexedSet(range(100000)) rands = [ord(r) for r in urandom(len(big_set))] start_time, start_size = time.time(), len(big_set) while len(big_set) > 10000: if len(big_set) % 10000 == 0: print(len(big_set) / 10000) rand = rands.pop() big_set.pop(rand) big_set.pop(-rand) end_time, end_size = time.time(), len(big_set) print() print('popped %s items in %s seconds' % (start_size - end_size, end_time - start_time))
def test_indexed_set_basic(): zero2nine = IndexedSet(range(10)) five2nine = zero2nine & IndexedSet(range(5, 15)) x = IndexedSet(five2nine) x |= set([10]) assert list(zero2nine) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] assert set(zero2nine) == set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) assert list(five2nine) == [5, 6, 7, 8, 9] assert x == IndexedSet([5, 6, 7, 8, 9, 10]) assert x[-1] == 10 assert zero2nine ^ five2nine == IndexedSet([0, 1, 2, 3, 4]) assert x[:3] == IndexedSet([5, 6, 7]) assert x[2:4:-1] == IndexedSet([8, 7])
def by_external_id(self, external_id, record_types=None): '''return any resources fetched from the 'by-external-id' route. Note: while the route will return differently depending on how many records are returned, this method deliberately flattens that out - it will _always_ return a generator, even if only one record is found.''' params = {"eid": external_id} if record_types: params['type[]'] = record_types res = self.client.get('by-external-id', params=params) if res.status_code == 404: return [] elif res.status_code == 300: # multiple returns, bare list of uris yield from (wrap_json_object({"ref": uri}, self.client) for uri in IndexedSet(res.json())) elif res.status_code == 200: # single obj, redirects to obj with 303->200 yield wrap_json_object(res.json(), self.client) else: raise ASnakeBadReturnCode("by-external-id call returned '{}'".format(res.status_code))
def generate_code(self) -> str: if not self._reset: _logger.error( "generate_code() called before the code has been reset. Call reset() first." ) return "" # Step 1, copy all lines from the code up until the first function self._generated_code = self.code[0:self._functions_start_line].copy() # Step 2, insert uniforms for all connected nodes for each unconnected argument for needed_code in self.connected_code: needed_code._reset = False prim_func = needed_code.get_primary_function() for arg in prim_func.arguments: if not arg.is_connected( ) and arg.name != "frag_pos" and not arg.is_output(): self._generated_code.append(arg.get_uniform_string() + "\n") self._uniforms.append((arg.type, arg.modified_name)) # Step 3, handle imports all_imports = IndexedSet([ im for n in self.connected_code for im in n.imports ]) # Convert to set to remove double imports for import_file in all_imports: print("Import File: {}".format(import_file)) libcode = generate_comment_line( import_file) + "\n" + get_import_code(import_file) self._generated_code.append(libcode + "\n") # Step 4, import code from connected nodes var_declarations = [] function_calls = [] added_function_defs = [] _add_calls(self, var_declarations, function_calls, added_function_defs, self._generated_code) # Step 5, generate calls to connected functions in own primary function self.primary_function.add_calls(function_calls, var_declarations) primary_code = "".join(self.primary_function.generated_code) self._generated_code.append(primary_code) self._reset = False return "".join(self._generated_code)
def dedupe(*input_files): """ Takes file descriptors and return deduplicated content. """ # Parse and merge all files entries. results = chain.from_iterable(imap(parse_history, input_files)) # Deduplicate entries sharing the same timestamp by removing all previous # occurences, only keeping the last one. A reverse IndexedSet let us keep # entries ordered by their encounter. This is important, especially to keep # together timestamp-less entries coming from the same file. results = IndexedSet(list(results)[::-1]) results.reverse() # Sort entries by timestamps. entries = [] for timestamp, cmd in sorted(results, key=itemgetter(0)): entries.append("#{}\n{}".format(timestamp, cmd)) return '\n'.join(entries)