def __setitem__(self, key, value): if key in self: del self[key] elif len(self) == self.size: self.popitem(last=False) OrderedDict.__setitem__(self, key, value)
class InfoRow(): def __init__(self): self.dict=OrderedDict() def __getitem__(self, item): if isinstance(item, int): return self.dict.items()[item][1] return self.dict.__getitem__(item.lower()) def __contains__(self, item): return self.dict.__contains__(item.lower()) def __setitem__(self, key, value): if isinstance(key, int): self.dict.items()[key][1]=value self.dict.__setitem__(key.lower(),value) def get(self, k, d=None): if isinstance(k, int): try: return self.dict.items()[k][1] except: return d return self.dict.get(k.lower(), d) def __str__(self, rowSeparator="\n", columnSeparator="\t"): return getStr(dict2Str(self.dict)) def __unicode__(self): return str(self) def __repr__(self): return str(self)
def parsepdf(filename): fp = open(filename, 'rb') parser = PDFParser(fp) # Create a PDF document object that stores the document structure. # Supply the password for initialization. document = PDFDocument(parser) # Check if the document allows text extraction. If not, abort. if not document.is_extractable: raise PDFTextExtractionNotAllowed # Create a PDF resource manager object that stores shared resources. rsrcmgr = PDFResourceManager() laparams = LAParams() # Create a PDF device object. device = PDFPageAggregator(rsrcmgr, laparams=laparams) # Create a PDF interpreter object. interpreter = PDFPageInterpreter(rsrcmgr, device) # Process each page contained in the document. found_randers = False found_aarhus = False _randers = [] headings = [u'Ledige lejligheder\n',u'afd. adresse\n',u'rum m2\n',u'leje \n', u'a\xb4c varme a\xb4c vand\n',u'indskud\n',u'ledig pr.\n',u'bem\xe6rkning\n' ] location_map = OrderedDict() header_ycord = [] for page in PDFPage.create_pages(document): interpreter.process_page(page) layout = device.get_result() for obj in layout._objs: # print obj if isinstance(obj,LTTextBoxHorizontal): for o in obj._objs: y0 = o.y0 # print o if isinstance(o,LTTextLineHorizontal) and obj.get_text() not in headings: if y0 not in header_ycord: if y0 in location_map : objs = location_map.get(y0) else: objs = [] string_val = o.get_text().encode('ascii', 'ignore') string_val = string_val.replace('\n','') objs.append(string_val) location_map.__setitem__(y0,objs) else : if y0 not in header_ycord: header_ycord.append(y0) for key in location_map: print '**************************' # # print key print location_map.get(key) print '**************************' print 'Total Rowss = %s'%len(location_map)
def __setitem__(self, key, value, PREV=0, NEXT=1, dict_setitem=dict.__setitem__): if self.__disabled: raise KeyError("you cannot change instance of request data") elif not isinstance(value, (list, rdict, ufile)): raise ValueError("value has to be list, rdict or ufile") else: #elif key not in self: OrderedDict.__setitem__(self, key, value, PREV, NEXT, dict_setitem)
def add(self, item): """ Add an element to an OrderedSet. This has no effect if the element is already present. """ OrderedDict.__setitem__(self, item, None)
class Metadata(MutableMapping): def __init__(self, seq=None): self.dct = OrderedDict(seq) if seq else OrderedDict() def __contains__(self, key): return self.dct.__contains__(key) def __getitem__(self, key): return self.dct.__getitem__(key) def __setitem__(self, key, value): self.dct.__setitem__(key, value) def __delitem__(self, key): return self.dct.__delitem__(key) def __iter__(self): return self.dct.__iter__() def __len__(self): return self.dct.__len__() def __repr__(self): return repr(self.dct) def __str__(self): return str(self.dct)
def databaseSchemaBuilder(connection): d=OrderedDict() sql="SELECT SCHEMA_NAME,DEFAULT_CHARACTER_SET_NAME,DEFAULT_COLLATION_NAME FROM information_schema.SCHEMATA" if connection.database: sql+=" WHERE SCHEMA_NAME = '{}'" else: params=None cur=None try: cur=connection.cursor(dictionary=True, buffered=True) cur.execute(sql.format(connection.database)) result=cur.fetchall() except Exception as e: raise e finally: if cur: cur.close() if result: for db in result: name =db.get('SCHEMA_NAME') database = DatabaseSchema(name=name,parent=connection) database.options['charset']=db['DEFAULT_CHARACTER_SET_NAME'] database.options['collation']=db['DEFAULT_COLLATION_NAME'] d.__setitem__(name,database) return d
def __setitem__(self, key, value): """ Set d[key] to value. """ with self.lock: if len(self) == self.max_len: self.popitem(last=False) OrderedDict.__setitem__(self, key,value) self.key_time_map[key] = {}
def __setitem__(self, key, val): kl = key.lower() if kl in self.keyMap: OrderedDict.__setitem__(self, self.keyMap[kl], val) else: OrderedDict.__setitem__(self, key, val) self.keyMap[kl] = key
def __setitem__(self, key, value): """ >>> T = pykov.Matrix() >>> T[('A','B')] = .3 >>> T {('A', 'B'): 0.3} >>> T['A','A'] = .7 >>> T {('A', 'B'): 0.3, ('A', 'A'): 0.7} >>> T['B','B'] = 0 >>> T {('A', 'B'): 0.3, ('A', 'A'): 0.7} >>> T['A','A'] = 0 >>> T {('A', 'B'): 0.3} >>> T = pykov.Matrix({('A','B'): 3, ('A','A'): 7, ('B','A'): .1}) >>> T.states() {'A', 'B'} >>> T['A','C']=1 >>> T.states() {'A', 'B', 'C'} >>> T['A','C']=0 >>> T.states() {'A', 'B'} """ if abs(value) > numpy.finfo(numpy.float).eps: OrderedDict.__setitem__(self, key, value) elif key in self: del(self[key])
def test_super_model_pack(self): self.assertEqual('m=api&f=getModel&module=product&methodName=getList',self.client._super_model_pack('product', 'getList')) self.assertEqual('m=api&f=getModel&module=testcase&methodName=getModuleCases¶ms=productID=2', self.client._super_model_pack('testcase', 'getModuleCases', {'productID': 2})) order=OrderedDict() order.__setitem__('productID',2) order.__setitem__('type','done') self.assertEqual('m=api&f=getModel&module=testcase&methodName=getModuleCases¶ms=productID=2,type=done', self.client._super_model_pack('testcase', 'getModuleCases', order))
class DebugBox(Window): def __init__(self,*args): super(DebugBox,self).__init__(*args) self.attr_list = OrderedDict() self.next_free = 1 def register(self,text,width,win): ''' store details of watch in an ordered dict of tuples dict1{"attr"+win} = attr, win_ref, width, index index = order on the screen (y coord) ''' if not self.attr_list.has_key(text + str(win)): self.attr_list.__setitem__(text + str(win),(text,win,width,self.next_free)) self.next_free += 1 else: pass #raise Exception # nothing should try to register twice def run(self): while 1: for key in self.attr_list.keys(): text,win,width,index = self.attr_list.__getitem__(key) self.addstr_no_cursor(text,index,1,width,win) time.sleep(1) self.refresh()
def finalize_container(self, cc, key): if self.cont_type != 'l': OrderedDict.__setitem__(cc, key, self.constructor(cc.is_pending[key])) else: OrderedDict.__setitem__(cc, key, cc.is_pending[key]) del cc.is_pending[key]
def __setitem__(self, key, value): if key in self: del self[key] elif len(self) >= self.maxSize: # Remove the least recently used cached data self.popitem(last=False) OrderedDict.__setitem__(self, key, value)
def __setitem__(self, key, par): #if key not in self: # if not valid_symbol_name(key): # raise KeyError("'%s' is not a valid Parameters name" % key) if par is not None and not isinstance(par, (Parameter, PyRhOparameter)): raise ValueError("'%s' is not a Parameter" % par) OrderedDict.__setitem__(self, key, par) par.name = key
def __setitem__(self, key, value): if key not in self: if not valid_symbol_name(key): raise KeyError("'%s' is not a valid Parameters name" % key) if value is not None and not isinstance(value, Parameter): raise ValueError("'%s' is not a Parameter" % value) OrderedDict.__setitem__(self, key, value) value.name = key
def __setitem__(self, key, value): OrderedDict.__setitem__(self, key, value) # force regen on next __str__ call self.cdxline = None # force regen on next to_json() call self._cached_json = None
def get(self, key): if key in self: value = self[key] del self[key] OrderedDict.__setitem__(self, key, value) return value else: return -1
def use(self, key, default = None): if key in self: value = OrderedDict.__getitem__(self, key) OrderedDict.__delitem__(self, key) OrderedDict.__setitem__(self, key, value) return value else: return default
class ATimeCache(object): """Cache class (dictionary) with a limited size, where only the 'max_entries' most recently added or accessed entries are stored.""" def __init__(self, max_entries): self._cache = OrderedDict() self._max_entries = max_entries def _shrink(self): while len(self._cache) > self._max_entries: self._cache.popitem(last=False) def get_max_entries(self): return self._max_entries def set_max_entries(self, value): self._max_entries = value self._shrink() max_entries = property( get_max_entries, set_max_entries, None, "Set or get the cache size") def has_key(self, key): return self._cache.has_key(key) def __eq__(self, other): try: return self._cache.__eq__(other._cache) except: return False def __len__(self): return self._cache.__len__() def __getitem__(self, key): value = self._cache.pop(key) self._cache[key] = value return value def __setitem__(self, key, value): if self._cache.has_key(key): self._cache.pop(key) self._cache.__setitem__(key, value) self._shrink() def __contains__(self, key): return self.has_key(key) def __str__(self): return self.cache.__str__() def __iter__(self): # Iterate directly on the underlying dict, rather than on this # class, in order to change the order of cached items (as # opposed to []/__getitem__, which will reinsert an item on top # of the stack whenever it is looked up. return iter(self._cache)
def __setitem__(self, key, value): """ Set a key/value pair in the dict. At the end, this function will check if old objects should be removed. :param key: a string key :param value: a value """ OrderedDict.__setitem__(self, key, value) self._remove_old_items()
def __setitem__(self, key, value): """ Set d[key] to value. """ with self.lock: if len(self) == self.max_len: try: self.popitem(last=False) except KeyError: pass OrderedDict.__setitem__(self, key, (value, time.time()))
def set(self, key, value): if key in self: del self[key] else: if self._count >= self._capacity: self.popitem(self, False) else: self._count += 1 OrderedDict.__setitem__(self, key, value)
def __setitem__(self, key, val): if isinstance(val,str): val = Cut(val) elif not isinstance(val,Cut): raise TypeError('CutFlow need CutSteps') val.name = key OrderedDict.__setitem__(self,key,val)
def add(self, name, value): """Adds a new value for the given key.""" norm_name = HTTPHeaders._normalize_name(name) if norm_name in self: # bypass our override of __setitem__ since it modifies _as_list OrderedDict.__setitem__(self, norm_name, self[norm_name] + ',' + value) self._as_list[norm_name].append(value) else: self[norm_name] = value
def copy(self): """The copy method of the superclass simply calls the constructor, which in turn calls the update method, which in turns calls __setitem__. This subclass implementation bypasses the expensive validation in __setitem__ for a substantial speedup.""" obj = self.__class__() for (attr, value) in self.iteritems(): OrderedDict.__setitem__(obj, attr, copy.copy(value)) return obj
def resetDict(): '''resets dictionary so as to empty fields for next iteration''' for x in heading1: # inserting elements of heading of file1 with default value "-" # so as to fill empty fields OrderedDict.__setitem__(dictionary1, x, "-") # print dictionary1 for x in heading2: # inserting elements of heading of file2 also remembering the order OrderedDict.__setitem__(dictionary1, x, "-")
def __setitem__(self, item, value, **kwargs): if isinstance(value, np.ndarray): if value.shape == self.shape: OrderedDict.__setitem__(self, item, value, **kwargs) else: raise ValueError("flags array shape {0} does not match data " "shape {1}".format(value.shape, self.shape)) else: raise TypeError("flags should be given as a Numpy array")
def __setitem__(self, key, par): if key not in self: if not valid_symbol_name(key): raise KeyError("'%s' is not a valid Parameters name" % key) if par is not None and not isinstance(par, Parameter): raise ValueError("'%s' is not a Parameter" % par) OrderedDict.__setitem__(self, key, par) par.name = key par._expr_eval = self._asteval self._asteval.symtable[key] = par.value
def __getitem__(self, key, *args, **kwargs): # Get the key and remove it from the cache, or raise KeyError value = OrderedDict.__getitem__(self, key) del self[key] # Insert the (key, value) pair on the front of the cache OrderedDict.__setitem__(self, key, value) # Return the value from the cache return value
def __setitem__(self, key, value): global CONFIG_MODIFIED OrderedDict.__setitem__(self, key, value) CONFIG_MODIFIED = True
def __setitem__(self, key, val): if isinstance(val, OrderedDict): self._unique += 1 key += "_" + str(self._unique) OrderedDict.__setitem__(self, key, val)
def __setitem__(self, key, value): if self.maxlen is not None and len(self) >= self.maxlen: self.popitem(0) #pop oldest OrderedDict.__setitem__(self, key, value)
def __setitem__(self, key, value): if (len(self) > self._size): last = self.popitem(last=True) print('remove', last) OrderedDict.__setitem__(self, key, value)
def __setitem__(self, *args, **kwargs): """Make sure that we don't set the default value!""" self._allow_contains_default = False return_value = OrderedDict.__setitem__(self, *args, **kwargs) self._allow_contains_default = True return return_value
def process_table_records(driver,table_records): ''' Parameters table_records -> Table Row data and the no weeks they need to be mapped against Form a Table such as ; Sys Title Sales Week Publisher ReleaseDate The n.o. weeks are fetched from the Headers, map sales data for each week against the records ''' for row_value,week_start_dates in table_records: ''' Unpack it to obtain the rows data and week array ''' ''' Get value of attribute - get_occurrences_weeks_in_headers getattr(sys.modules[__name__],"get_occurrences_weeks_in_headers") and map sales for each week against the Week ''' get_start , get_end = getattr(sys.modules[__name__],"get_occurrences_weeks_in_headers") ''' Now Slice the table row accordingly ''' get_rows_sales_data = row_value.__getslice__(get_start,get_end+1) get_sys_title = row_value[0:get_start] get_publisher_release_date = row_value[get_end+1:] ''' Create an OrderedDict of Weekly Sales and Week Start Dates , insertion order is very important while we publish the sales table Sys Title Sales Week Publisher ReleaseDate ''' get_weekly_sales_data = OrderedDict() core_logger.info("Creating a Table of records .... ") core_logger.info("\n\n\n\n") for sales_data,week_start_date in zip(get_rows_sales_data,week_start_dates): try: get_weekly_sales_data.__setitem__("System",u''.join(get_sys_title.__getitem__(0)).encode('utf-8').strip()) get_weekly_sales_data.__setitem__("Title",u''.join(get_sys_title.__getitem__(1)).encode('utf-8').strip()) get_weekly_sales_data.__setitem__("Sales",float(sales_data)) get_weekly_sales_data.__setitem__("Week",week_start_date.isoformat()) get_weekly_sales_data.__setitem__("Publisher",u''.join(get_publisher_release_date.__getitem__(0)).encode('utf-8').strip()) get_weekly_sales_data.__setitem__("ReleaseDate",u''.join(get_publisher_release_date.__getitem__(1)).encode('utf-8').strip()) yield get_weekly_sales_data except Exception as E: core_logger.critical(E) continue
def lookup(self, key): with self.lock: value = OrderedDict.__getitem__(self, key) del self[key] OrderedDict.__setitem__(self, key, value) return value
def __setattr__(self, name, value): if hasattr(self, '_sync') and self._sync: OrderedDict.__setitem__(self, name, value) OrderedDict.__setattr__(self, name, value)
class ParameditWidget(QWidget): """ This class represents a pane where parameter editor widgets of multiple nodes are shown. In rqt_reconfigure, this pane occupies right half of the entire visible area. """ # public signal sig_node_disabled_selected = Signal(str) def __init__(self, rospack): """""" super(ParameditWidget, self).__init__() ui_file = os.path.join(rospack.get_path('rqt_reconfigure'), 'resource', 'paramedit_pane.ui') loadUi(ui_file, self, {'ParameditWidget': ParameditWidget}) self._param_clients = OrderedDict() # Adding the list of Items self.vlayout = QVBoxLayout(self.scrollarea_holder_widget) # causes error # self._set_index_widgets(self.listview, paramitems_dict) self.destroyed.connect(self.close) def _set_index_widgets(self, view, paramitems_dict): """ @deprecated: Causes error """ i = 0 for p in paramitems_dict: view.setIndexWidget(i, p) i += 1 def show_reconf(self, param_client_widget): """ Callback when user chooses a node. @param param_client_widget: """ node_grn = param_client_widget.get_node_grn() logging.debug('ParameditWidget.show str(node_grn)=%s', str(node_grn)) if node_grn not in self._param_clients.keys(): # Add param widget if there isn't already one. # Client gets renewed every time different node_grn was clicked. self._param_clients.__setitem__(node_grn, param_client_widget) self.vlayout.addWidget(param_client_widget) param_client_widget.sig_node_disabled_selected.connect( self._node_disabled) else: # If there has one already existed, remove it. self._remove_node(node_grn) # LayoutUtil.clear_layout(self.vlayout) # Re-add the rest of existing items to layout. # for k, v in self._param_clients.items(): # logging.info('added to layout k={} v={}'.format(k, v)) # self.vlayout.addWidget(v) # Add color to alternate the rim of the widget. LayoutUtil.alternate_color(self._param_clients.values(), [ self.palette().window().color().lighter(125), self.palette().window().color().darker(125) ]) def close(self): for dc in self._param_clients: # Clear out the old widget dc.close() dc = None self._paramedit_scrollarea.deleteLater() def filter_param(self, filter_key): """ :type filter_key: """ # TODO Pick nodes that match filter_key. # TODO For the nodes that are kept in previous step, call # ParamClientWidget.filter_param for all of its existing # instances. pass def _remove_node(self, node_grn): try: i = self._param_clients.keys().index(node_grn) except ValueError: # ValueError occurring here means that the specified key is not # found, most likely already removed, which is possible in the # following situation/sequence: # # Node widget on ParameditWidget removed by clicking disable button # --> Node deselected on tree widget gets updated # --> Tree widget detects deselection # --> Tree widget emits deselection signal, which is captured by # ParameditWidget's slot. Thus reaches this method again. return item = self.vlayout.itemAt(i) if isinstance(item, QWidgetItem): item.widget().close() w = self._param_clients.pop(node_grn) logging.debug('popped={} Len of left clients={}'.format( w, len(self._param_clients))) def _node_disabled(self, node_grn): logging.debug('paramedit_w _node_disabled grn={}'.format(node_grn)) # Signal to notify other GUI components (eg. nodes tree pane) that # a node widget is disabled. self.sig_node_disabled_selected.emit(node_grn) # Remove the selected node widget from the internal list of nodes. self._remove_node(node_grn)
def __setitem__(self, key, val): if isinstance(val, dict) and key == "Preset": self._unique += 1 key += str(self._unique) OrderedDict.__setitem__(self, key, val)
def __setitem__(self, key, value): with self._lock: OrderedDict.__setitem__(self, key, value) self._checklen()
def __setitem__(self, key, item): if isinstance(key, six.string_types): (key, item) = self._EncodeKeyValues(key, item) OrderedDict.__setitem__(self, key, item) else: OrderedDict.__setitem__(self, key, item)
def __setitem__(self, key, value): value = self._convert_nested_dicts(value) OrderedDict.__setitem__(self, key, value)
def __setitem__(self, key, val): if isinstance(val, OrderedDict): self._unique += 1 key = f"{str(self._unique)}. [{key}]" OrderedDict.__setitem__(self, key, val)
def __setitem__(self, key, value, **kwargs): with self.lock: OrderedDict.__setitem__(self, key, (value, time.time()), **kwargs)
def __setitem__(self, key, value): OrderedDict.__setitem__(self, key, value) self.move_to_end(key)
def __setitem__(self, key, value): OrderedDict.__setitem__(self, key, value) self._check_size_limit()
def __setitem__(self, key: KT, value: VT) -> None: """Add a new element to the dict.""" OrderedDict.__setitem__(self, key, value) if self._max > 0: if len(self) > self._max: self.popitem(False)
def __setitem__(self, *args, **kwargs): if self.readonly: raise KeyError("object in read-only mode") else: return OrderedDict.__setitem__(self, *args, **kwargs)
def __setitem__(self, key, value): with self.lock: if self.cache_size is not None and key not in self: if len(self) >= self.cache_size: self.popitem(last=False) OrderedDict.__setitem__(self, key, value)
def __setitem__(self, key, value): if key not in self: OrderedDict.__setitem__(self, key, value) else: raise KeyError("Key already exists")
def __setitem__(self, key: CacheKey, value: CacheValue) -> None: """Store a new views, potentially discarding an old value.""" if key not in self: if len(self) >= self.cache_size: self.popitem(last=False) OrderedDict.__setitem__(self, key, value)
def __setattr__(self, name, value): if not hasattr(self, '_init'): return OrderedDict.__setattr__(self, name, value) return OrderedDict.__setitem__(self, name, value)
def __setitem__(self, k, v): return OrderedDict.__setitem__(self, Point(*k), v)
def __setitem__(self, key, val): if isinstance(val, OrderedDict): self._unique += 1 key = "{}. [{}]".format(str(self._unique), key) OrderedDict.__setitem__(self, key, val)
def __setitem__(self, key, value): OrderedDict.__setitem__(self, key, value) if self._max > 0: if len(self) > self._max: self.popitem(False)
def getAWSServiceControlPolicy(data_path, account_name): with open( os.path.join(data_path, account_name, "organizations", 'organizations-list-policies.json'), 'r') as filein: file_content = json.loads(filein.read()) jqQuery = '.Policies[].Id' service_control_policies = pyjq.all(jqQuery, file_content) scp_list = [] for service_control_policy in service_control_policies: with open( os.path.join(data_path, account_name, "organizations", "organizations-describe-policy", service_control_policy), 'r') as filein: file_content = json.loads(filein.read()) policy_details = OrderedDict() policy_details.__setitem__( 'Id', file_content['Policy']['PolicySummary']['Id']) policy_details.__setitem__( 'Arn', file_content['Policy']['PolicySummary']['Arn']) policy_details.__setitem__( 'Name', file_content['Policy']['PolicySummary']['Name']) policy_details.__setitem__( 'Description', file_content['Policy']['PolicySummary']['Description']) policy_details.__setitem__( 'AwsManaged', file_content['Policy']['PolicySummary']['AwsManaged']) policy_details.__setitem__( 'Content', json.loads(file_content['Policy']['Content'])) scp_list.append(policy_details) return scp_list
def __setitem__(self, key, value): if key in self: del self[key] OrderedDict.__setitem__(self, key, value)
def __setitem__(self, key, value): with self.lock: if len(self) >= self.max_len: self.popitem(last=False) OrderedDict.__setitem__(self, key, (value, time()))
def __setitem__(self, key, val): if hasattr(self, '_sync') and self._sync: OrderedDict.__setattr__(self, key, val) OrderedDict.__setitem__(self, key, val)