Ejemplo n.º 1
0
    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)
Ejemplo n.º 2
0
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)
Ejemplo n.º 3
0
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)
Ejemplo n.º 4
0
 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)
Ejemplo n.º 5
0
    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)
Ejemplo n.º 6
0
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)
Ejemplo n.º 7
0
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
Ejemplo n.º 8
0
 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] = {}
Ejemplo n.º 9
0
 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
Ejemplo n.º 10
0
    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&params=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&params=productID=2,type=done', self.client._super_model_pack('testcase', 'getModuleCases', order))
Ejemplo n.º 12
0
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()
Ejemplo n.º 13
0
   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]
Ejemplo n.º 14
0
 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)
Ejemplo n.º 15
0
 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
Ejemplo n.º 16
0
 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
Ejemplo n.º 17
0
    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
Ejemplo n.º 18
0
 def get(self, key):
     if key in self:
         value = self[key]
         del self[key]
         OrderedDict.__setitem__(self, key, value)
         return value
     else:
         return -1
Ejemplo n.º 19
0
 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
Ejemplo n.º 20
0
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)
Ejemplo n.º 21
0
 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()
Ejemplo n.º 22
0
 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()))
Ejemplo n.º 23
0
 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)
Ejemplo n.º 24
0
    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)
Ejemplo n.º 25
0
 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
Ejemplo n.º 26
0
 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
Ejemplo n.º 27
0
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, "-")
Ejemplo n.º 28
0
    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")
Ejemplo n.º 29
0
 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
Ejemplo n.º 30
0
        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
Ejemplo n.º 31
0
 def __setitem__(self, key, value):
     global CONFIG_MODIFIED
     OrderedDict.__setitem__(self, key, value)
     CONFIG_MODIFIED = True
Ejemplo n.º 32
0
 def __setitem__(self, key, val):
     if isinstance(val, OrderedDict):
         self._unique += 1
         key += "_" + str(self._unique)
     OrderedDict.__setitem__(self, key, val)
Ejemplo n.º 33
0
 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)
Ejemplo n.º 34
0
 def __setitem__(self, key, value):
     if (len(self) > self._size):
         last = self.popitem(last=True)
         print('remove', last)
     OrderedDict.__setitem__(self, key, value)
Ejemplo n.º 35
0
 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
Ejemplo n.º 36
0
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
Ejemplo n.º 37
0
 def lookup(self, key):
     with self.lock:
         value = OrderedDict.__getitem__(self, key)
         del self[key]
         OrderedDict.__setitem__(self, key, value)
         return value
Ejemplo n.º 38
0
    def __setattr__(self, name, value):
        if hasattr(self, '_sync') and self._sync:
            OrderedDict.__setitem__(self, name, value)

        OrderedDict.__setattr__(self, name, value)
Ejemplo n.º 39
0
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)
Ejemplo n.º 40
0
 def __setitem__(self, key, val):
     if isinstance(val, dict) and key == "Preset":
         self._unique += 1
         key += str(self._unique)
     OrderedDict.__setitem__(self, key, val)
Ejemplo n.º 41
0
 def __setitem__(self, key, value):
     with self._lock:
         OrderedDict.__setitem__(self, key, value)
         self._checklen()
Ejemplo n.º 42
0
 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)
Ejemplo n.º 43
0
 def __setitem__(self, key, value):
     value = self._convert_nested_dicts(value)
     OrderedDict.__setitem__(self, key, value)
Ejemplo n.º 44
0
 def __setitem__(self, key, val):
     if isinstance(val, OrderedDict):
         self._unique += 1
         key = f"{str(self._unique)}. [{key}]"
     OrderedDict.__setitem__(self, key, val)
Ejemplo n.º 45
0
 def __setitem__(self, key, value, **kwargs):
     with self.lock:
         OrderedDict.__setitem__(self, key, (value, time.time()), **kwargs)
Ejemplo n.º 46
0
 def __setitem__(self, key, value):
     OrderedDict.__setitem__(self, key, value)
     self.move_to_end(key)
Ejemplo n.º 47
0
 def __setitem__(self, key, value):
   OrderedDict.__setitem__(self, key, value)
   self._check_size_limit()
Ejemplo n.º 48
0
 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)
Ejemplo n.º 49
0
 def __setitem__(self, *args, **kwargs):
     if self.readonly:
         raise KeyError("object in read-only mode")
     else:
         return OrderedDict.__setitem__(self, *args, **kwargs)
Ejemplo n.º 50
0
 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)
Ejemplo n.º 51
0
 def __setitem__(self, key, value):
     if key not in self:
         OrderedDict.__setitem__(self, key, value)
     else:
         raise KeyError("Key already exists")
Ejemplo n.º 52
0
 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)
Ejemplo n.º 53
0
 def __setattr__(self, name, value):
     if not hasattr(self, '_init'):
         return OrderedDict.__setattr__(self, name, value)
     return OrderedDict.__setitem__(self, name, value)
Ejemplo n.º 54
0
 def __setitem__(self, k, v):
     return OrderedDict.__setitem__(self, Point(*k), v)
Ejemplo n.º 55
0
 def __setitem__(self, key, val):
     if isinstance(val, OrderedDict):
         self._unique += 1
         key = "{}. [{}]".format(str(self._unique), key)
     OrderedDict.__setitem__(self, key, val)
Ejemplo n.º 56
0
 def __setitem__(self, key, value):
     OrderedDict.__setitem__(self, key, value)
     if self._max > 0:
         if len(self) > self._max:
             self.popitem(False)
Ejemplo n.º 57
0
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
Ejemplo n.º 58
0
 def __setitem__(self, key, value):
     if key in self:
         del self[key]
     OrderedDict.__setitem__(self, key, value)
Ejemplo n.º 59
0
 def __setitem__(self, key, value):
     with self.lock:
         if len(self) >= self.max_len:
             self.popitem(last=False)
         OrderedDict.__setitem__(self, key, (value, time()))
Ejemplo n.º 60
0
 def __setitem__(self, key, val):
     if hasattr(self, '_sync') and self._sync:
         OrderedDict.__setattr__(self, key, val)
     OrderedDict.__setitem__(self, key, val)